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/gke/_inputs.py
CHANGED
|
@@ -1,76 +1,161 @@
|
|
|
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
|
'ElastigroupBackendServiceArgs',
|
|
19
|
+
'ElastigroupBackendServiceArgsDict',
|
|
20
|
+
'ElastigroupBackendServiceBackendBalancingArgs',
|
|
21
|
+
'ElastigroupBackendServiceBackendBalancingArgsDict',
|
|
14
22
|
'ElastigroupBackendServiceNamedPortArgs',
|
|
23
|
+
'ElastigroupBackendServiceNamedPortArgsDict',
|
|
15
24
|
'ElastigroupDiskArgs',
|
|
25
|
+
'ElastigroupDiskArgsDict',
|
|
16
26
|
'ElastigroupDiskInitializeParamArgs',
|
|
27
|
+
'ElastigroupDiskInitializeParamArgsDict',
|
|
17
28
|
'ElastigroupGpuArgs',
|
|
29
|
+
'ElastigroupGpuArgsDict',
|
|
18
30
|
'ElastigroupInstanceTypesCustomArgs',
|
|
31
|
+
'ElastigroupInstanceTypesCustomArgsDict',
|
|
19
32
|
'ElastigroupIntegrationDockerSwarmArgs',
|
|
33
|
+
'ElastigroupIntegrationDockerSwarmArgsDict',
|
|
20
34
|
'ElastigroupIntegrationGkeArgs',
|
|
35
|
+
'ElastigroupIntegrationGkeArgsDict',
|
|
21
36
|
'ElastigroupIntegrationGkeAutoscaleDownArgs',
|
|
37
|
+
'ElastigroupIntegrationGkeAutoscaleDownArgsDict',
|
|
22
38
|
'ElastigroupIntegrationGkeAutoscaleHeadroomArgs',
|
|
39
|
+
'ElastigroupIntegrationGkeAutoscaleHeadroomArgsDict',
|
|
23
40
|
'ElastigroupIntegrationGkeAutoscaleLabelArgs',
|
|
41
|
+
'ElastigroupIntegrationGkeAutoscaleLabelArgsDict',
|
|
24
42
|
'ElastigroupLabelArgs',
|
|
43
|
+
'ElastigroupLabelArgsDict',
|
|
25
44
|
'ElastigroupMetadataArgs',
|
|
45
|
+
'ElastigroupMetadataArgsDict',
|
|
26
46
|
'ElastigroupNetworkInterfaceArgs',
|
|
47
|
+
'ElastigroupNetworkInterfaceArgsDict',
|
|
27
48
|
'ElastigroupNetworkInterfaceAccessConfigArgs',
|
|
49
|
+
'ElastigroupNetworkInterfaceAccessConfigArgsDict',
|
|
28
50
|
'ElastigroupNetworkInterfaceAliasIpRangeArgs',
|
|
51
|
+
'ElastigroupNetworkInterfaceAliasIpRangeArgsDict',
|
|
52
|
+
'ElastigroupRevertToPreemptibleArgs',
|
|
53
|
+
'ElastigroupRevertToPreemptibleArgsDict',
|
|
29
54
|
'ElastigroupScalingDownPolicyArgs',
|
|
55
|
+
'ElastigroupScalingDownPolicyArgsDict',
|
|
30
56
|
'ElastigroupScalingDownPolicyDimensionArgs',
|
|
57
|
+
'ElastigroupScalingDownPolicyDimensionArgsDict',
|
|
31
58
|
'ElastigroupScalingUpPolicyArgs',
|
|
59
|
+
'ElastigroupScalingUpPolicyArgsDict',
|
|
32
60
|
'ElastigroupScalingUpPolicyDimensionArgs',
|
|
61
|
+
'ElastigroupScalingUpPolicyDimensionArgsDict',
|
|
62
|
+
'ElastigroupShieldedInstanceConfigArgs',
|
|
63
|
+
'ElastigroupShieldedInstanceConfigArgsDict',
|
|
64
|
+
'OceanImportAutoUpdateArgs',
|
|
65
|
+
'OceanImportAutoUpdateArgsDict',
|
|
33
66
|
'OceanImportAutoscalerArgs',
|
|
67
|
+
'OceanImportAutoscalerArgsDict',
|
|
34
68
|
'OceanImportAutoscalerDownArgs',
|
|
69
|
+
'OceanImportAutoscalerDownArgsDict',
|
|
35
70
|
'OceanImportAutoscalerHeadroomArgs',
|
|
71
|
+
'OceanImportAutoscalerHeadroomArgsDict',
|
|
36
72
|
'OceanImportAutoscalerResourceLimitsArgs',
|
|
73
|
+
'OceanImportAutoscalerResourceLimitsArgsDict',
|
|
37
74
|
'OceanImportBackendServiceArgs',
|
|
75
|
+
'OceanImportBackendServiceArgsDict',
|
|
38
76
|
'OceanImportBackendServiceNamedPortArgs',
|
|
77
|
+
'OceanImportBackendServiceNamedPortArgsDict',
|
|
78
|
+
'OceanImportFiltersArgs',
|
|
79
|
+
'OceanImportFiltersArgsDict',
|
|
39
80
|
'OceanImportScheduledTaskArgs',
|
|
81
|
+
'OceanImportScheduledTaskArgsDict',
|
|
40
82
|
'OceanImportScheduledTaskShutdownHoursArgs',
|
|
83
|
+
'OceanImportScheduledTaskShutdownHoursArgsDict',
|
|
41
84
|
'OceanImportScheduledTaskTaskArgs',
|
|
85
|
+
'OceanImportScheduledTaskTaskArgsDict',
|
|
42
86
|
'OceanImportScheduledTaskTaskTaskParametersArgs',
|
|
87
|
+
'OceanImportScheduledTaskTaskTaskParametersArgsDict',
|
|
43
88
|
'OceanImportScheduledTaskTaskTaskParametersClusterRollArgs',
|
|
89
|
+
'OceanImportScheduledTaskTaskTaskParametersClusterRollArgsDict',
|
|
44
90
|
'OceanImportShieldedInstanceConfigArgs',
|
|
91
|
+
'OceanImportShieldedInstanceConfigArgsDict',
|
|
45
92
|
'OceanImportStrategyArgs',
|
|
93
|
+
'OceanImportStrategyArgsDict',
|
|
46
94
|
'OceanImportUpdatePolicyArgs',
|
|
95
|
+
'OceanImportUpdatePolicyArgsDict',
|
|
47
96
|
'OceanImportUpdatePolicyRollConfigArgs',
|
|
97
|
+
'OceanImportUpdatePolicyRollConfigArgsDict',
|
|
48
98
|
'OceanLaunchSpecAutoscaleHeadroomArgs',
|
|
99
|
+
'OceanLaunchSpecAutoscaleHeadroomArgsDict',
|
|
49
100
|
'OceanLaunchSpecAutoscaleHeadroomsAutomaticArgs',
|
|
101
|
+
'OceanLaunchSpecAutoscaleHeadroomsAutomaticArgsDict',
|
|
102
|
+
'OceanLaunchSpecCreateOptionsArgs',
|
|
103
|
+
'OceanLaunchSpecCreateOptionsArgsDict',
|
|
104
|
+
'OceanLaunchSpecFiltersArgs',
|
|
105
|
+
'OceanLaunchSpecFiltersArgsDict',
|
|
50
106
|
'OceanLaunchSpecLabelArgs',
|
|
107
|
+
'OceanLaunchSpecLabelArgsDict',
|
|
51
108
|
'OceanLaunchSpecMetadataArgs',
|
|
109
|
+
'OceanLaunchSpecMetadataArgsDict',
|
|
52
110
|
'OceanLaunchSpecNetworkInterfaceArgs',
|
|
111
|
+
'OceanLaunchSpecNetworkInterfaceArgsDict',
|
|
53
112
|
'OceanLaunchSpecNetworkInterfaceAccessConfigArgs',
|
|
113
|
+
'OceanLaunchSpecNetworkInterfaceAccessConfigArgsDict',
|
|
54
114
|
'OceanLaunchSpecNetworkInterfaceAliasIpRangeArgs',
|
|
115
|
+
'OceanLaunchSpecNetworkInterfaceAliasIpRangeArgsDict',
|
|
55
116
|
'OceanLaunchSpecResourceLimitsArgs',
|
|
117
|
+
'OceanLaunchSpecResourceLimitsArgsDict',
|
|
56
118
|
'OceanLaunchSpecSchedulingTaskArgs',
|
|
119
|
+
'OceanLaunchSpecSchedulingTaskArgsDict',
|
|
57
120
|
'OceanLaunchSpecSchedulingTaskTaskHeadroomArgs',
|
|
121
|
+
'OceanLaunchSpecSchedulingTaskTaskHeadroomArgsDict',
|
|
58
122
|
'OceanLaunchSpecShieldedInstanceConfigArgs',
|
|
123
|
+
'OceanLaunchSpecShieldedInstanceConfigArgsDict',
|
|
59
124
|
'OceanLaunchSpecStorageArgs',
|
|
125
|
+
'OceanLaunchSpecStorageArgsDict',
|
|
60
126
|
'OceanLaunchSpecStrategyArgs',
|
|
127
|
+
'OceanLaunchSpecStrategyArgsDict',
|
|
61
128
|
'OceanLaunchSpecTaintArgs',
|
|
129
|
+
'OceanLaunchSpecTaintArgsDict',
|
|
62
130
|
'OceanLaunchSpecUpdatePolicyArgs',
|
|
131
|
+
'OceanLaunchSpecUpdatePolicyArgsDict',
|
|
63
132
|
'OceanLaunchSpecUpdatePolicyRollConfigArgs',
|
|
133
|
+
'OceanLaunchSpecUpdatePolicyRollConfigArgsDict',
|
|
64
134
|
]
|
|
65
135
|
|
|
136
|
+
MYPY = False
|
|
137
|
+
|
|
138
|
+
if not MYPY:
|
|
139
|
+
class ElastigroupBackendServiceArgsDict(TypedDict):
|
|
140
|
+
service_name: pulumi.Input[_builtins.str]
|
|
141
|
+
backend_balancing: NotRequired[pulumi.Input['ElastigroupBackendServiceBackendBalancingArgsDict']]
|
|
142
|
+
location_type: NotRequired[pulumi.Input[_builtins.str]]
|
|
143
|
+
named_ports: NotRequired[pulumi.Input[Sequence[pulumi.Input['ElastigroupBackendServiceNamedPortArgsDict']]]]
|
|
144
|
+
scheme: NotRequired[pulumi.Input[_builtins.str]]
|
|
145
|
+
elif False:
|
|
146
|
+
ElastigroupBackendServiceArgsDict: TypeAlias = Mapping[str, Any]
|
|
147
|
+
|
|
66
148
|
@pulumi.input_type
|
|
67
149
|
class ElastigroupBackendServiceArgs:
|
|
68
150
|
def __init__(__self__, *,
|
|
69
|
-
service_name: pulumi.Input[str],
|
|
70
|
-
|
|
151
|
+
service_name: pulumi.Input[_builtins.str],
|
|
152
|
+
backend_balancing: Optional[pulumi.Input['ElastigroupBackendServiceBackendBalancingArgs']] = None,
|
|
153
|
+
location_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
71
154
|
named_ports: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupBackendServiceNamedPortArgs']]]] = None,
|
|
72
|
-
scheme: Optional[pulumi.Input[str]] = None):
|
|
155
|
+
scheme: Optional[pulumi.Input[_builtins.str]] = None):
|
|
73
156
|
pulumi.set(__self__, "service_name", service_name)
|
|
157
|
+
if backend_balancing is not None:
|
|
158
|
+
pulumi.set(__self__, "backend_balancing", backend_balancing)
|
|
74
159
|
if location_type is not None:
|
|
75
160
|
pulumi.set(__self__, "location_type", location_type)
|
|
76
161
|
if named_ports is not None:
|
|
@@ -78,25 +163,34 @@ class ElastigroupBackendServiceArgs:
|
|
|
78
163
|
if scheme is not None:
|
|
79
164
|
pulumi.set(__self__, "scheme", scheme)
|
|
80
165
|
|
|
81
|
-
@property
|
|
166
|
+
@_builtins.property
|
|
82
167
|
@pulumi.getter(name="serviceName")
|
|
83
|
-
def service_name(self) -> pulumi.Input[str]:
|
|
168
|
+
def service_name(self) -> pulumi.Input[_builtins.str]:
|
|
84
169
|
return pulumi.get(self, "service_name")
|
|
85
170
|
|
|
86
171
|
@service_name.setter
|
|
87
|
-
def service_name(self, value: pulumi.Input[str]):
|
|
172
|
+
def service_name(self, value: pulumi.Input[_builtins.str]):
|
|
88
173
|
pulumi.set(self, "service_name", value)
|
|
89
174
|
|
|
90
|
-
@property
|
|
175
|
+
@_builtins.property
|
|
176
|
+
@pulumi.getter(name="backendBalancing")
|
|
177
|
+
def backend_balancing(self) -> Optional[pulumi.Input['ElastigroupBackendServiceBackendBalancingArgs']]:
|
|
178
|
+
return pulumi.get(self, "backend_balancing")
|
|
179
|
+
|
|
180
|
+
@backend_balancing.setter
|
|
181
|
+
def backend_balancing(self, value: Optional[pulumi.Input['ElastigroupBackendServiceBackendBalancingArgs']]):
|
|
182
|
+
pulumi.set(self, "backend_balancing", value)
|
|
183
|
+
|
|
184
|
+
@_builtins.property
|
|
91
185
|
@pulumi.getter(name="locationType")
|
|
92
|
-
def location_type(self) -> Optional[pulumi.Input[str]]:
|
|
186
|
+
def location_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
93
187
|
return pulumi.get(self, "location_type")
|
|
94
188
|
|
|
95
189
|
@location_type.setter
|
|
96
|
-
def location_type(self, value: Optional[pulumi.Input[str]]):
|
|
190
|
+
def location_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
97
191
|
pulumi.set(self, "location_type", value)
|
|
98
192
|
|
|
99
|
-
@property
|
|
193
|
+
@_builtins.property
|
|
100
194
|
@pulumi.getter(name="namedPorts")
|
|
101
195
|
def named_ports(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupBackendServiceNamedPortArgs']]]]:
|
|
102
196
|
return pulumi.get(self, "named_ports")
|
|
@@ -105,54 +199,110 @@ class ElastigroupBackendServiceArgs:
|
|
|
105
199
|
def named_ports(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupBackendServiceNamedPortArgs']]]]):
|
|
106
200
|
pulumi.set(self, "named_ports", value)
|
|
107
201
|
|
|
108
|
-
@property
|
|
202
|
+
@_builtins.property
|
|
109
203
|
@pulumi.getter
|
|
110
|
-
def scheme(self) -> Optional[pulumi.Input[str]]:
|
|
204
|
+
def scheme(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
111
205
|
return pulumi.get(self, "scheme")
|
|
112
206
|
|
|
113
207
|
@scheme.setter
|
|
114
|
-
def scheme(self, value: Optional[pulumi.Input[str]]):
|
|
208
|
+
def scheme(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
115
209
|
pulumi.set(self, "scheme", value)
|
|
116
210
|
|
|
117
211
|
|
|
212
|
+
if not MYPY:
|
|
213
|
+
class ElastigroupBackendServiceBackendBalancingArgsDict(TypedDict):
|
|
214
|
+
backend_balancing_mode: NotRequired[pulumi.Input[_builtins.str]]
|
|
215
|
+
max_rate_per_instance: NotRequired[pulumi.Input[_builtins.int]]
|
|
216
|
+
elif False:
|
|
217
|
+
ElastigroupBackendServiceBackendBalancingArgsDict: TypeAlias = Mapping[str, Any]
|
|
218
|
+
|
|
219
|
+
@pulumi.input_type
|
|
220
|
+
class ElastigroupBackendServiceBackendBalancingArgs:
|
|
221
|
+
def __init__(__self__, *,
|
|
222
|
+
backend_balancing_mode: Optional[pulumi.Input[_builtins.str]] = None,
|
|
223
|
+
max_rate_per_instance: Optional[pulumi.Input[_builtins.int]] = None):
|
|
224
|
+
if backend_balancing_mode is not None:
|
|
225
|
+
pulumi.set(__self__, "backend_balancing_mode", backend_balancing_mode)
|
|
226
|
+
if max_rate_per_instance is not None:
|
|
227
|
+
pulumi.set(__self__, "max_rate_per_instance", max_rate_per_instance)
|
|
228
|
+
|
|
229
|
+
@_builtins.property
|
|
230
|
+
@pulumi.getter(name="backendBalancingMode")
|
|
231
|
+
def backend_balancing_mode(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
232
|
+
return pulumi.get(self, "backend_balancing_mode")
|
|
233
|
+
|
|
234
|
+
@backend_balancing_mode.setter
|
|
235
|
+
def backend_balancing_mode(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
236
|
+
pulumi.set(self, "backend_balancing_mode", value)
|
|
237
|
+
|
|
238
|
+
@_builtins.property
|
|
239
|
+
@pulumi.getter(name="maxRatePerInstance")
|
|
240
|
+
def max_rate_per_instance(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
241
|
+
return pulumi.get(self, "max_rate_per_instance")
|
|
242
|
+
|
|
243
|
+
@max_rate_per_instance.setter
|
|
244
|
+
def max_rate_per_instance(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
245
|
+
pulumi.set(self, "max_rate_per_instance", value)
|
|
246
|
+
|
|
247
|
+
|
|
248
|
+
if not MYPY:
|
|
249
|
+
class ElastigroupBackendServiceNamedPortArgsDict(TypedDict):
|
|
250
|
+
name: pulumi.Input[_builtins.str]
|
|
251
|
+
ports: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]
|
|
252
|
+
elif False:
|
|
253
|
+
ElastigroupBackendServiceNamedPortArgsDict: TypeAlias = Mapping[str, Any]
|
|
254
|
+
|
|
118
255
|
@pulumi.input_type
|
|
119
256
|
class ElastigroupBackendServiceNamedPortArgs:
|
|
120
257
|
def __init__(__self__, *,
|
|
121
|
-
name: pulumi.Input[str],
|
|
122
|
-
ports: pulumi.Input[Sequence[pulumi.Input[str]]]):
|
|
258
|
+
name: pulumi.Input[_builtins.str],
|
|
259
|
+
ports: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]):
|
|
123
260
|
pulumi.set(__self__, "name", name)
|
|
124
261
|
pulumi.set(__self__, "ports", ports)
|
|
125
262
|
|
|
126
|
-
@property
|
|
263
|
+
@_builtins.property
|
|
127
264
|
@pulumi.getter
|
|
128
|
-
def name(self) -> pulumi.Input[str]:
|
|
265
|
+
def name(self) -> pulumi.Input[_builtins.str]:
|
|
129
266
|
return pulumi.get(self, "name")
|
|
130
267
|
|
|
131
268
|
@name.setter
|
|
132
|
-
def name(self, value: pulumi.Input[str]):
|
|
269
|
+
def name(self, value: pulumi.Input[_builtins.str]):
|
|
133
270
|
pulumi.set(self, "name", value)
|
|
134
271
|
|
|
135
|
-
@property
|
|
272
|
+
@_builtins.property
|
|
136
273
|
@pulumi.getter
|
|
137
|
-
def ports(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
|
|
274
|
+
def ports(self) -> pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]:
|
|
138
275
|
return pulumi.get(self, "ports")
|
|
139
276
|
|
|
140
277
|
@ports.setter
|
|
141
|
-
def ports(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
|
|
278
|
+
def ports(self, value: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]):
|
|
142
279
|
pulumi.set(self, "ports", value)
|
|
143
280
|
|
|
144
281
|
|
|
282
|
+
if not MYPY:
|
|
283
|
+
class ElastigroupDiskArgsDict(TypedDict):
|
|
284
|
+
auto_delete: NotRequired[pulumi.Input[_builtins.bool]]
|
|
285
|
+
boot: NotRequired[pulumi.Input[_builtins.bool]]
|
|
286
|
+
device_name: NotRequired[pulumi.Input[_builtins.str]]
|
|
287
|
+
initialize_params: NotRequired[pulumi.Input[Sequence[pulumi.Input['ElastigroupDiskInitializeParamArgsDict']]]]
|
|
288
|
+
interface: NotRequired[pulumi.Input[_builtins.str]]
|
|
289
|
+
mode: NotRequired[pulumi.Input[_builtins.str]]
|
|
290
|
+
source: NotRequired[pulumi.Input[_builtins.str]]
|
|
291
|
+
type: NotRequired[pulumi.Input[_builtins.str]]
|
|
292
|
+
elif False:
|
|
293
|
+
ElastigroupDiskArgsDict: TypeAlias = Mapping[str, Any]
|
|
294
|
+
|
|
145
295
|
@pulumi.input_type
|
|
146
296
|
class ElastigroupDiskArgs:
|
|
147
297
|
def __init__(__self__, *,
|
|
148
|
-
auto_delete: Optional[pulumi.Input[bool]] = None,
|
|
149
|
-
boot: Optional[pulumi.Input[bool]] = None,
|
|
150
|
-
device_name: Optional[pulumi.Input[str]] = None,
|
|
298
|
+
auto_delete: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
299
|
+
boot: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
300
|
+
device_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
151
301
|
initialize_params: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupDiskInitializeParamArgs']]]] = None,
|
|
152
|
-
interface: Optional[pulumi.Input[str]] = None,
|
|
153
|
-
mode: Optional[pulumi.Input[str]] = None,
|
|
154
|
-
source: Optional[pulumi.Input[str]] = None,
|
|
155
|
-
type: Optional[pulumi.Input[str]] = None):
|
|
302
|
+
interface: Optional[pulumi.Input[_builtins.str]] = None,
|
|
303
|
+
mode: Optional[pulumi.Input[_builtins.str]] = None,
|
|
304
|
+
source: Optional[pulumi.Input[_builtins.str]] = None,
|
|
305
|
+
type: Optional[pulumi.Input[_builtins.str]] = None):
|
|
156
306
|
if auto_delete is not None:
|
|
157
307
|
pulumi.set(__self__, "auto_delete", auto_delete)
|
|
158
308
|
if boot is not None:
|
|
@@ -170,34 +320,34 @@ class ElastigroupDiskArgs:
|
|
|
170
320
|
if type is not None:
|
|
171
321
|
pulumi.set(__self__, "type", type)
|
|
172
322
|
|
|
173
|
-
@property
|
|
323
|
+
@_builtins.property
|
|
174
324
|
@pulumi.getter(name="autoDelete")
|
|
175
|
-
def auto_delete(self) -> Optional[pulumi.Input[bool]]:
|
|
325
|
+
def auto_delete(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
176
326
|
return pulumi.get(self, "auto_delete")
|
|
177
327
|
|
|
178
328
|
@auto_delete.setter
|
|
179
|
-
def auto_delete(self, value: Optional[pulumi.Input[bool]]):
|
|
329
|
+
def auto_delete(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
180
330
|
pulumi.set(self, "auto_delete", value)
|
|
181
331
|
|
|
182
|
-
@property
|
|
332
|
+
@_builtins.property
|
|
183
333
|
@pulumi.getter
|
|
184
|
-
def boot(self) -> Optional[pulumi.Input[bool]]:
|
|
334
|
+
def boot(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
185
335
|
return pulumi.get(self, "boot")
|
|
186
336
|
|
|
187
337
|
@boot.setter
|
|
188
|
-
def boot(self, value: Optional[pulumi.Input[bool]]):
|
|
338
|
+
def boot(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
189
339
|
pulumi.set(self, "boot", value)
|
|
190
340
|
|
|
191
|
-
@property
|
|
341
|
+
@_builtins.property
|
|
192
342
|
@pulumi.getter(name="deviceName")
|
|
193
|
-
def device_name(self) -> Optional[pulumi.Input[str]]:
|
|
343
|
+
def device_name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
194
344
|
return pulumi.get(self, "device_name")
|
|
195
345
|
|
|
196
346
|
@device_name.setter
|
|
197
|
-
def device_name(self, value: Optional[pulumi.Input[str]]):
|
|
347
|
+
def device_name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
198
348
|
pulumi.set(self, "device_name", value)
|
|
199
349
|
|
|
200
|
-
@property
|
|
350
|
+
@_builtins.property
|
|
201
351
|
@pulumi.getter(name="initializeParams")
|
|
202
352
|
def initialize_params(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupDiskInitializeParamArgs']]]]:
|
|
203
353
|
return pulumi.get(self, "initialize_params")
|
|
@@ -206,176 +356,245 @@ class ElastigroupDiskArgs:
|
|
|
206
356
|
def initialize_params(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupDiskInitializeParamArgs']]]]):
|
|
207
357
|
pulumi.set(self, "initialize_params", value)
|
|
208
358
|
|
|
209
|
-
@property
|
|
359
|
+
@_builtins.property
|
|
210
360
|
@pulumi.getter
|
|
211
|
-
def interface(self) -> Optional[pulumi.Input[str]]:
|
|
361
|
+
def interface(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
212
362
|
return pulumi.get(self, "interface")
|
|
213
363
|
|
|
214
364
|
@interface.setter
|
|
215
|
-
def interface(self, value: Optional[pulumi.Input[str]]):
|
|
365
|
+
def interface(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
216
366
|
pulumi.set(self, "interface", value)
|
|
217
367
|
|
|
218
|
-
@property
|
|
368
|
+
@_builtins.property
|
|
219
369
|
@pulumi.getter
|
|
220
|
-
def mode(self) -> Optional[pulumi.Input[str]]:
|
|
370
|
+
def mode(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
221
371
|
return pulumi.get(self, "mode")
|
|
222
372
|
|
|
223
373
|
@mode.setter
|
|
224
|
-
def mode(self, value: Optional[pulumi.Input[str]]):
|
|
374
|
+
def mode(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
225
375
|
pulumi.set(self, "mode", value)
|
|
226
376
|
|
|
227
|
-
@property
|
|
377
|
+
@_builtins.property
|
|
228
378
|
@pulumi.getter
|
|
229
|
-
def source(self) -> Optional[pulumi.Input[str]]:
|
|
379
|
+
def source(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
230
380
|
return pulumi.get(self, "source")
|
|
231
381
|
|
|
232
382
|
@source.setter
|
|
233
|
-
def source(self, value: Optional[pulumi.Input[str]]):
|
|
383
|
+
def source(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
234
384
|
pulumi.set(self, "source", value)
|
|
235
385
|
|
|
236
|
-
@property
|
|
386
|
+
@_builtins.property
|
|
237
387
|
@pulumi.getter
|
|
238
|
-
def type(self) -> Optional[pulumi.Input[str]]:
|
|
388
|
+
def type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
239
389
|
return pulumi.get(self, "type")
|
|
240
390
|
|
|
241
391
|
@type.setter
|
|
242
|
-
def type(self, value: Optional[pulumi.Input[str]]):
|
|
392
|
+
def type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
243
393
|
pulumi.set(self, "type", value)
|
|
244
394
|
|
|
245
395
|
|
|
396
|
+
if not MYPY:
|
|
397
|
+
class ElastigroupDiskInitializeParamArgsDict(TypedDict):
|
|
398
|
+
source_image: pulumi.Input[_builtins.str]
|
|
399
|
+
disk_size_gb: NotRequired[pulumi.Input[_builtins.str]]
|
|
400
|
+
disk_type: NotRequired[pulumi.Input[_builtins.str]]
|
|
401
|
+
elif False:
|
|
402
|
+
ElastigroupDiskInitializeParamArgsDict: TypeAlias = Mapping[str, Any]
|
|
403
|
+
|
|
246
404
|
@pulumi.input_type
|
|
247
405
|
class ElastigroupDiskInitializeParamArgs:
|
|
248
406
|
def __init__(__self__, *,
|
|
249
|
-
source_image: pulumi.Input[str],
|
|
250
|
-
disk_size_gb: Optional[pulumi.Input[str]] = None,
|
|
251
|
-
disk_type: Optional[pulumi.Input[str]] = None):
|
|
407
|
+
source_image: pulumi.Input[_builtins.str],
|
|
408
|
+
disk_size_gb: Optional[pulumi.Input[_builtins.str]] = None,
|
|
409
|
+
disk_type: Optional[pulumi.Input[_builtins.str]] = None):
|
|
252
410
|
pulumi.set(__self__, "source_image", source_image)
|
|
253
411
|
if disk_size_gb is not None:
|
|
254
412
|
pulumi.set(__self__, "disk_size_gb", disk_size_gb)
|
|
255
413
|
if disk_type is not None:
|
|
256
414
|
pulumi.set(__self__, "disk_type", disk_type)
|
|
257
415
|
|
|
258
|
-
@property
|
|
416
|
+
@_builtins.property
|
|
259
417
|
@pulumi.getter(name="sourceImage")
|
|
260
|
-
def source_image(self) -> pulumi.Input[str]:
|
|
418
|
+
def source_image(self) -> pulumi.Input[_builtins.str]:
|
|
261
419
|
return pulumi.get(self, "source_image")
|
|
262
420
|
|
|
263
421
|
@source_image.setter
|
|
264
|
-
def source_image(self, value: pulumi.Input[str]):
|
|
422
|
+
def source_image(self, value: pulumi.Input[_builtins.str]):
|
|
265
423
|
pulumi.set(self, "source_image", value)
|
|
266
424
|
|
|
267
|
-
@property
|
|
425
|
+
@_builtins.property
|
|
268
426
|
@pulumi.getter(name="diskSizeGb")
|
|
269
|
-
def disk_size_gb(self) -> Optional[pulumi.Input[str]]:
|
|
427
|
+
def disk_size_gb(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
270
428
|
return pulumi.get(self, "disk_size_gb")
|
|
271
429
|
|
|
272
430
|
@disk_size_gb.setter
|
|
273
|
-
def disk_size_gb(self, value: Optional[pulumi.Input[str]]):
|
|
431
|
+
def disk_size_gb(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
274
432
|
pulumi.set(self, "disk_size_gb", value)
|
|
275
433
|
|
|
276
|
-
@property
|
|
434
|
+
@_builtins.property
|
|
277
435
|
@pulumi.getter(name="diskType")
|
|
278
|
-
def disk_type(self) -> Optional[pulumi.Input[str]]:
|
|
436
|
+
def disk_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
279
437
|
return pulumi.get(self, "disk_type")
|
|
280
438
|
|
|
281
439
|
@disk_type.setter
|
|
282
|
-
def disk_type(self, value: Optional[pulumi.Input[str]]):
|
|
440
|
+
def disk_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
283
441
|
pulumi.set(self, "disk_type", value)
|
|
284
442
|
|
|
285
443
|
|
|
444
|
+
if not MYPY:
|
|
445
|
+
class ElastigroupGpuArgsDict(TypedDict):
|
|
446
|
+
count: pulumi.Input[_builtins.int]
|
|
447
|
+
type: pulumi.Input[_builtins.str]
|
|
448
|
+
elif False:
|
|
449
|
+
ElastigroupGpuArgsDict: TypeAlias = Mapping[str, Any]
|
|
450
|
+
|
|
286
451
|
@pulumi.input_type
|
|
287
452
|
class ElastigroupGpuArgs:
|
|
288
453
|
def __init__(__self__, *,
|
|
289
|
-
count: pulumi.Input[int],
|
|
290
|
-
type: pulumi.Input[str]):
|
|
454
|
+
count: pulumi.Input[_builtins.int],
|
|
455
|
+
type: pulumi.Input[_builtins.str]):
|
|
291
456
|
pulumi.set(__self__, "count", count)
|
|
292
457
|
pulumi.set(__self__, "type", type)
|
|
293
458
|
|
|
294
|
-
@property
|
|
459
|
+
@_builtins.property
|
|
295
460
|
@pulumi.getter
|
|
296
|
-
def count(self) -> pulumi.Input[int]:
|
|
461
|
+
def count(self) -> pulumi.Input[_builtins.int]:
|
|
297
462
|
return pulumi.get(self, "count")
|
|
298
463
|
|
|
299
464
|
@count.setter
|
|
300
|
-
def count(self, value: pulumi.Input[int]):
|
|
465
|
+
def count(self, value: pulumi.Input[_builtins.int]):
|
|
301
466
|
pulumi.set(self, "count", value)
|
|
302
467
|
|
|
303
|
-
@property
|
|
468
|
+
@_builtins.property
|
|
304
469
|
@pulumi.getter
|
|
305
|
-
def type(self) -> pulumi.Input[str]:
|
|
470
|
+
def type(self) -> pulumi.Input[_builtins.str]:
|
|
306
471
|
return pulumi.get(self, "type")
|
|
307
472
|
|
|
308
473
|
@type.setter
|
|
309
|
-
def type(self, value: pulumi.Input[str]):
|
|
474
|
+
def type(self, value: pulumi.Input[_builtins.str]):
|
|
310
475
|
pulumi.set(self, "type", value)
|
|
311
476
|
|
|
312
477
|
|
|
478
|
+
if not MYPY:
|
|
479
|
+
class ElastigroupInstanceTypesCustomArgsDict(TypedDict):
|
|
480
|
+
memory_gib: pulumi.Input[_builtins.int]
|
|
481
|
+
vcpu: pulumi.Input[_builtins.int]
|
|
482
|
+
elif False:
|
|
483
|
+
ElastigroupInstanceTypesCustomArgsDict: TypeAlias = Mapping[str, Any]
|
|
484
|
+
|
|
313
485
|
@pulumi.input_type
|
|
314
486
|
class ElastigroupInstanceTypesCustomArgs:
|
|
315
487
|
def __init__(__self__, *,
|
|
316
|
-
memory_gib: pulumi.Input[int],
|
|
317
|
-
vcpu: pulumi.Input[int]):
|
|
488
|
+
memory_gib: pulumi.Input[_builtins.int],
|
|
489
|
+
vcpu: pulumi.Input[_builtins.int]):
|
|
318
490
|
pulumi.set(__self__, "memory_gib", memory_gib)
|
|
319
491
|
pulumi.set(__self__, "vcpu", vcpu)
|
|
320
492
|
|
|
321
|
-
@property
|
|
493
|
+
@_builtins.property
|
|
322
494
|
@pulumi.getter(name="memoryGib")
|
|
323
|
-
def memory_gib(self) -> pulumi.Input[int]:
|
|
495
|
+
def memory_gib(self) -> pulumi.Input[_builtins.int]:
|
|
324
496
|
return pulumi.get(self, "memory_gib")
|
|
325
497
|
|
|
326
498
|
@memory_gib.setter
|
|
327
|
-
def memory_gib(self, value: pulumi.Input[int]):
|
|
499
|
+
def memory_gib(self, value: pulumi.Input[_builtins.int]):
|
|
328
500
|
pulumi.set(self, "memory_gib", value)
|
|
329
501
|
|
|
330
|
-
@property
|
|
502
|
+
@_builtins.property
|
|
331
503
|
@pulumi.getter
|
|
332
|
-
def vcpu(self) -> pulumi.Input[int]:
|
|
504
|
+
def vcpu(self) -> pulumi.Input[_builtins.int]:
|
|
333
505
|
return pulumi.get(self, "vcpu")
|
|
334
506
|
|
|
335
507
|
@vcpu.setter
|
|
336
|
-
def vcpu(self, value: pulumi.Input[int]):
|
|
508
|
+
def vcpu(self, value: pulumi.Input[_builtins.int]):
|
|
337
509
|
pulumi.set(self, "vcpu", value)
|
|
338
510
|
|
|
339
511
|
|
|
512
|
+
if not MYPY:
|
|
513
|
+
class ElastigroupIntegrationDockerSwarmArgsDict(TypedDict):
|
|
514
|
+
master_host: pulumi.Input[_builtins.str]
|
|
515
|
+
master_port: pulumi.Input[_builtins.int]
|
|
516
|
+
elif False:
|
|
517
|
+
ElastigroupIntegrationDockerSwarmArgsDict: TypeAlias = Mapping[str, Any]
|
|
518
|
+
|
|
340
519
|
@pulumi.input_type
|
|
341
520
|
class ElastigroupIntegrationDockerSwarmArgs:
|
|
342
521
|
def __init__(__self__, *,
|
|
343
|
-
master_host: pulumi.Input[str],
|
|
344
|
-
master_port: pulumi.Input[int]):
|
|
522
|
+
master_host: pulumi.Input[_builtins.str],
|
|
523
|
+
master_port: pulumi.Input[_builtins.int]):
|
|
345
524
|
pulumi.set(__self__, "master_host", master_host)
|
|
346
525
|
pulumi.set(__self__, "master_port", master_port)
|
|
347
526
|
|
|
348
|
-
@property
|
|
527
|
+
@_builtins.property
|
|
349
528
|
@pulumi.getter(name="masterHost")
|
|
350
|
-
def master_host(self) -> pulumi.Input[str]:
|
|
529
|
+
def master_host(self) -> pulumi.Input[_builtins.str]:
|
|
351
530
|
return pulumi.get(self, "master_host")
|
|
352
531
|
|
|
353
532
|
@master_host.setter
|
|
354
|
-
def master_host(self, value: pulumi.Input[str]):
|
|
533
|
+
def master_host(self, value: pulumi.Input[_builtins.str]):
|
|
355
534
|
pulumi.set(self, "master_host", value)
|
|
356
535
|
|
|
357
|
-
@property
|
|
536
|
+
@_builtins.property
|
|
358
537
|
@pulumi.getter(name="masterPort")
|
|
359
|
-
def master_port(self) -> pulumi.Input[int]:
|
|
538
|
+
def master_port(self) -> pulumi.Input[_builtins.int]:
|
|
360
539
|
return pulumi.get(self, "master_port")
|
|
361
540
|
|
|
362
541
|
@master_port.setter
|
|
363
|
-
def master_port(self, value: pulumi.Input[int]):
|
|
542
|
+
def master_port(self, value: pulumi.Input[_builtins.int]):
|
|
364
543
|
pulumi.set(self, "master_port", value)
|
|
365
544
|
|
|
366
545
|
|
|
546
|
+
if not MYPY:
|
|
547
|
+
class ElastigroupIntegrationGkeArgsDict(TypedDict):
|
|
548
|
+
auto_update: NotRequired[pulumi.Input[_builtins.bool]]
|
|
549
|
+
autoscale_cooldown: NotRequired[pulumi.Input[_builtins.int]]
|
|
550
|
+
"""
|
|
551
|
+
The amount of time, in seconds, after a scaling activity completes before any further trigger-related scaling activities can start.
|
|
552
|
+
"""
|
|
553
|
+
autoscale_down: NotRequired[pulumi.Input['ElastigroupIntegrationGkeAutoscaleDownArgsDict']]
|
|
554
|
+
"""
|
|
555
|
+
Enabling scale down.
|
|
556
|
+
"""
|
|
557
|
+
autoscale_headroom: NotRequired[pulumi.Input['ElastigroupIntegrationGkeAutoscaleHeadroomArgsDict']]
|
|
558
|
+
"""
|
|
559
|
+
Headroom for the cluster.
|
|
560
|
+
"""
|
|
561
|
+
autoscale_is_auto_config: NotRequired[pulumi.Input[_builtins.bool]]
|
|
562
|
+
autoscale_is_enabled: NotRequired[pulumi.Input[_builtins.bool]]
|
|
563
|
+
"""
|
|
564
|
+
Specifies whether the auto scaling feature is enabled.
|
|
565
|
+
"""
|
|
566
|
+
autoscale_labels: NotRequired[pulumi.Input[Sequence[pulumi.Input['ElastigroupIntegrationGkeAutoscaleLabelArgsDict']]]]
|
|
567
|
+
"""
|
|
568
|
+
Labels to assign to the resource.
|
|
569
|
+
"""
|
|
570
|
+
cluster_id: NotRequired[pulumi.Input[_builtins.str]]
|
|
571
|
+
location: NotRequired[pulumi.Input[_builtins.str]]
|
|
572
|
+
"""
|
|
573
|
+
The location of your GKE cluster.
|
|
574
|
+
"""
|
|
575
|
+
elif False:
|
|
576
|
+
ElastigroupIntegrationGkeArgsDict: TypeAlias = Mapping[str, Any]
|
|
577
|
+
|
|
367
578
|
@pulumi.input_type
|
|
368
579
|
class ElastigroupIntegrationGkeArgs:
|
|
369
580
|
def __init__(__self__, *,
|
|
370
|
-
auto_update: Optional[pulumi.Input[bool]] = None,
|
|
371
|
-
autoscale_cooldown: Optional[pulumi.Input[int]] = None,
|
|
581
|
+
auto_update: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
582
|
+
autoscale_cooldown: Optional[pulumi.Input[_builtins.int]] = None,
|
|
372
583
|
autoscale_down: Optional[pulumi.Input['ElastigroupIntegrationGkeAutoscaleDownArgs']] = None,
|
|
373
584
|
autoscale_headroom: Optional[pulumi.Input['ElastigroupIntegrationGkeAutoscaleHeadroomArgs']] = None,
|
|
374
|
-
autoscale_is_auto_config: Optional[pulumi.Input[bool]] = None,
|
|
375
|
-
autoscale_is_enabled: Optional[pulumi.Input[bool]] = None,
|
|
585
|
+
autoscale_is_auto_config: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
586
|
+
autoscale_is_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
376
587
|
autoscale_labels: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupIntegrationGkeAutoscaleLabelArgs']]]] = None,
|
|
377
|
-
cluster_id: Optional[pulumi.Input[str]] = None,
|
|
378
|
-
location: Optional[pulumi.Input[str]] = None):
|
|
588
|
+
cluster_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
589
|
+
location: Optional[pulumi.Input[_builtins.str]] = None):
|
|
590
|
+
"""
|
|
591
|
+
:param pulumi.Input[_builtins.int] autoscale_cooldown: The amount of time, in seconds, after a scaling activity completes before any further trigger-related scaling activities can start.
|
|
592
|
+
:param pulumi.Input['ElastigroupIntegrationGkeAutoscaleDownArgs'] autoscale_down: Enabling scale down.
|
|
593
|
+
:param pulumi.Input['ElastigroupIntegrationGkeAutoscaleHeadroomArgs'] autoscale_headroom: Headroom for the cluster.
|
|
594
|
+
:param pulumi.Input[_builtins.bool] autoscale_is_enabled: Specifies whether the auto scaling feature is enabled.
|
|
595
|
+
:param pulumi.Input[Sequence[pulumi.Input['ElastigroupIntegrationGkeAutoscaleLabelArgs']]] autoscale_labels: Labels to assign to the resource.
|
|
596
|
+
:param pulumi.Input[_builtins.str] location: The location of your GKE cluster.
|
|
597
|
+
"""
|
|
379
598
|
if auto_update is not None:
|
|
380
599
|
pulumi.set(__self__, "auto_update", auto_update)
|
|
381
600
|
if autoscale_cooldown is not None:
|
|
@@ -395,111 +614,166 @@ class ElastigroupIntegrationGkeArgs:
|
|
|
395
614
|
if location is not None:
|
|
396
615
|
pulumi.set(__self__, "location", location)
|
|
397
616
|
|
|
398
|
-
@property
|
|
617
|
+
@_builtins.property
|
|
399
618
|
@pulumi.getter(name="autoUpdate")
|
|
400
|
-
def auto_update(self) -> Optional[pulumi.Input[bool]]:
|
|
619
|
+
def auto_update(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
401
620
|
return pulumi.get(self, "auto_update")
|
|
402
621
|
|
|
403
622
|
@auto_update.setter
|
|
404
|
-
def auto_update(self, value: Optional[pulumi.Input[bool]]):
|
|
623
|
+
def auto_update(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
405
624
|
pulumi.set(self, "auto_update", value)
|
|
406
625
|
|
|
407
|
-
@property
|
|
626
|
+
@_builtins.property
|
|
408
627
|
@pulumi.getter(name="autoscaleCooldown")
|
|
409
|
-
def autoscale_cooldown(self) -> Optional[pulumi.Input[int]]:
|
|
628
|
+
def autoscale_cooldown(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
629
|
+
"""
|
|
630
|
+
The amount of time, in seconds, after a scaling activity completes before any further trigger-related scaling activities can start.
|
|
631
|
+
"""
|
|
410
632
|
return pulumi.get(self, "autoscale_cooldown")
|
|
411
633
|
|
|
412
634
|
@autoscale_cooldown.setter
|
|
413
|
-
def autoscale_cooldown(self, value: Optional[pulumi.Input[int]]):
|
|
635
|
+
def autoscale_cooldown(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
414
636
|
pulumi.set(self, "autoscale_cooldown", value)
|
|
415
637
|
|
|
416
|
-
@property
|
|
638
|
+
@_builtins.property
|
|
417
639
|
@pulumi.getter(name="autoscaleDown")
|
|
418
640
|
def autoscale_down(self) -> Optional[pulumi.Input['ElastigroupIntegrationGkeAutoscaleDownArgs']]:
|
|
641
|
+
"""
|
|
642
|
+
Enabling scale down.
|
|
643
|
+
"""
|
|
419
644
|
return pulumi.get(self, "autoscale_down")
|
|
420
645
|
|
|
421
646
|
@autoscale_down.setter
|
|
422
647
|
def autoscale_down(self, value: Optional[pulumi.Input['ElastigroupIntegrationGkeAutoscaleDownArgs']]):
|
|
423
648
|
pulumi.set(self, "autoscale_down", value)
|
|
424
649
|
|
|
425
|
-
@property
|
|
650
|
+
@_builtins.property
|
|
426
651
|
@pulumi.getter(name="autoscaleHeadroom")
|
|
427
652
|
def autoscale_headroom(self) -> Optional[pulumi.Input['ElastigroupIntegrationGkeAutoscaleHeadroomArgs']]:
|
|
653
|
+
"""
|
|
654
|
+
Headroom for the cluster.
|
|
655
|
+
"""
|
|
428
656
|
return pulumi.get(self, "autoscale_headroom")
|
|
429
657
|
|
|
430
658
|
@autoscale_headroom.setter
|
|
431
659
|
def autoscale_headroom(self, value: Optional[pulumi.Input['ElastigroupIntegrationGkeAutoscaleHeadroomArgs']]):
|
|
432
660
|
pulumi.set(self, "autoscale_headroom", value)
|
|
433
661
|
|
|
434
|
-
@property
|
|
662
|
+
@_builtins.property
|
|
435
663
|
@pulumi.getter(name="autoscaleIsAutoConfig")
|
|
436
|
-
def autoscale_is_auto_config(self) -> Optional[pulumi.Input[bool]]:
|
|
664
|
+
def autoscale_is_auto_config(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
437
665
|
return pulumi.get(self, "autoscale_is_auto_config")
|
|
438
666
|
|
|
439
667
|
@autoscale_is_auto_config.setter
|
|
440
|
-
def autoscale_is_auto_config(self, value: Optional[pulumi.Input[bool]]):
|
|
668
|
+
def autoscale_is_auto_config(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
441
669
|
pulumi.set(self, "autoscale_is_auto_config", value)
|
|
442
670
|
|
|
443
|
-
@property
|
|
671
|
+
@_builtins.property
|
|
444
672
|
@pulumi.getter(name="autoscaleIsEnabled")
|
|
445
|
-
def autoscale_is_enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
673
|
+
def autoscale_is_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
674
|
+
"""
|
|
675
|
+
Specifies whether the auto scaling feature is enabled.
|
|
676
|
+
"""
|
|
446
677
|
return pulumi.get(self, "autoscale_is_enabled")
|
|
447
678
|
|
|
448
679
|
@autoscale_is_enabled.setter
|
|
449
|
-
def autoscale_is_enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
680
|
+
def autoscale_is_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
450
681
|
pulumi.set(self, "autoscale_is_enabled", value)
|
|
451
682
|
|
|
452
|
-
@property
|
|
683
|
+
@_builtins.property
|
|
453
684
|
@pulumi.getter(name="autoscaleLabels")
|
|
454
685
|
def autoscale_labels(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupIntegrationGkeAutoscaleLabelArgs']]]]:
|
|
686
|
+
"""
|
|
687
|
+
Labels to assign to the resource.
|
|
688
|
+
"""
|
|
455
689
|
return pulumi.get(self, "autoscale_labels")
|
|
456
690
|
|
|
457
691
|
@autoscale_labels.setter
|
|
458
692
|
def autoscale_labels(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupIntegrationGkeAutoscaleLabelArgs']]]]):
|
|
459
693
|
pulumi.set(self, "autoscale_labels", value)
|
|
460
694
|
|
|
461
|
-
@property
|
|
695
|
+
@_builtins.property
|
|
462
696
|
@pulumi.getter(name="clusterId")
|
|
463
|
-
def cluster_id(self) -> Optional[pulumi.Input[str]]:
|
|
697
|
+
def cluster_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
464
698
|
return pulumi.get(self, "cluster_id")
|
|
465
699
|
|
|
466
700
|
@cluster_id.setter
|
|
467
|
-
def cluster_id(self, value: Optional[pulumi.Input[str]]):
|
|
701
|
+
def cluster_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
468
702
|
pulumi.set(self, "cluster_id", value)
|
|
469
703
|
|
|
470
|
-
@property
|
|
704
|
+
@_builtins.property
|
|
471
705
|
@pulumi.getter
|
|
472
|
-
def location(self) -> Optional[pulumi.Input[str]]:
|
|
706
|
+
def location(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
707
|
+
"""
|
|
708
|
+
The location of your GKE cluster.
|
|
709
|
+
"""
|
|
473
710
|
return pulumi.get(self, "location")
|
|
474
711
|
|
|
475
712
|
@location.setter
|
|
476
|
-
def location(self, value: Optional[pulumi.Input[str]]):
|
|
713
|
+
def location(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
477
714
|
pulumi.set(self, "location", value)
|
|
478
715
|
|
|
479
716
|
|
|
717
|
+
if not MYPY:
|
|
718
|
+
class ElastigroupIntegrationGkeAutoscaleDownArgsDict(TypedDict):
|
|
719
|
+
evaluation_periods: NotRequired[pulumi.Input[_builtins.int]]
|
|
720
|
+
"""
|
|
721
|
+
Amount of cooldown evaluation periods for scale down.
|
|
722
|
+
"""
|
|
723
|
+
elif False:
|
|
724
|
+
ElastigroupIntegrationGkeAutoscaleDownArgsDict: TypeAlias = Mapping[str, Any]
|
|
725
|
+
|
|
480
726
|
@pulumi.input_type
|
|
481
727
|
class ElastigroupIntegrationGkeAutoscaleDownArgs:
|
|
482
728
|
def __init__(__self__, *,
|
|
483
|
-
evaluation_periods: Optional[pulumi.Input[int]] = None):
|
|
729
|
+
evaluation_periods: Optional[pulumi.Input[_builtins.int]] = None):
|
|
730
|
+
"""
|
|
731
|
+
:param pulumi.Input[_builtins.int] evaluation_periods: Amount of cooldown evaluation periods for scale down.
|
|
732
|
+
"""
|
|
484
733
|
if evaluation_periods is not None:
|
|
485
734
|
pulumi.set(__self__, "evaluation_periods", evaluation_periods)
|
|
486
735
|
|
|
487
|
-
@property
|
|
736
|
+
@_builtins.property
|
|
488
737
|
@pulumi.getter(name="evaluationPeriods")
|
|
489
|
-
def evaluation_periods(self) -> Optional[pulumi.Input[int]]:
|
|
738
|
+
def evaluation_periods(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
739
|
+
"""
|
|
740
|
+
Amount of cooldown evaluation periods for scale down.
|
|
741
|
+
"""
|
|
490
742
|
return pulumi.get(self, "evaluation_periods")
|
|
491
743
|
|
|
492
744
|
@evaluation_periods.setter
|
|
493
|
-
def evaluation_periods(self, value: Optional[pulumi.Input[int]]):
|
|
745
|
+
def evaluation_periods(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
494
746
|
pulumi.set(self, "evaluation_periods", value)
|
|
495
747
|
|
|
496
748
|
|
|
749
|
+
if not MYPY:
|
|
750
|
+
class ElastigroupIntegrationGkeAutoscaleHeadroomArgsDict(TypedDict):
|
|
751
|
+
cpu_per_unit: NotRequired[pulumi.Input[_builtins.int]]
|
|
752
|
+
"""
|
|
753
|
+
Cpu units for compute.
|
|
754
|
+
"""
|
|
755
|
+
memory_per_unit: NotRequired[pulumi.Input[_builtins.int]]
|
|
756
|
+
"""
|
|
757
|
+
RAM units for compute.
|
|
758
|
+
"""
|
|
759
|
+
num_of_units: NotRequired[pulumi.Input[_builtins.int]]
|
|
760
|
+
"""
|
|
761
|
+
Amount of units for compute.
|
|
762
|
+
"""
|
|
763
|
+
elif False:
|
|
764
|
+
ElastigroupIntegrationGkeAutoscaleHeadroomArgsDict: TypeAlias = Mapping[str, Any]
|
|
765
|
+
|
|
497
766
|
@pulumi.input_type
|
|
498
767
|
class ElastigroupIntegrationGkeAutoscaleHeadroomArgs:
|
|
499
768
|
def __init__(__self__, *,
|
|
500
|
-
cpu_per_unit: Optional[pulumi.Input[int]] = None,
|
|
501
|
-
memory_per_unit: Optional[pulumi.Input[int]] = None,
|
|
502
|
-
num_of_units: Optional[pulumi.Input[int]] = None):
|
|
769
|
+
cpu_per_unit: Optional[pulumi.Input[_builtins.int]] = None,
|
|
770
|
+
memory_per_unit: Optional[pulumi.Input[_builtins.int]] = None,
|
|
771
|
+
num_of_units: Optional[pulumi.Input[_builtins.int]] = None):
|
|
772
|
+
"""
|
|
773
|
+
:param pulumi.Input[_builtins.int] cpu_per_unit: Cpu units for compute.
|
|
774
|
+
:param pulumi.Input[_builtins.int] memory_per_unit: RAM units for compute.
|
|
775
|
+
:param pulumi.Input[_builtins.int] num_of_units: Amount of units for compute.
|
|
776
|
+
"""
|
|
503
777
|
if cpu_per_unit is not None:
|
|
504
778
|
pulumi.set(__self__, "cpu_per_unit", cpu_per_unit)
|
|
505
779
|
if memory_per_unit is not None:
|
|
@@ -507,119 +781,157 @@ class ElastigroupIntegrationGkeAutoscaleHeadroomArgs:
|
|
|
507
781
|
if num_of_units is not None:
|
|
508
782
|
pulumi.set(__self__, "num_of_units", num_of_units)
|
|
509
783
|
|
|
510
|
-
@property
|
|
784
|
+
@_builtins.property
|
|
511
785
|
@pulumi.getter(name="cpuPerUnit")
|
|
512
|
-
def cpu_per_unit(self) -> Optional[pulumi.Input[int]]:
|
|
786
|
+
def cpu_per_unit(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
787
|
+
"""
|
|
788
|
+
Cpu units for compute.
|
|
789
|
+
"""
|
|
513
790
|
return pulumi.get(self, "cpu_per_unit")
|
|
514
791
|
|
|
515
792
|
@cpu_per_unit.setter
|
|
516
|
-
def cpu_per_unit(self, value: Optional[pulumi.Input[int]]):
|
|
793
|
+
def cpu_per_unit(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
517
794
|
pulumi.set(self, "cpu_per_unit", value)
|
|
518
795
|
|
|
519
|
-
@property
|
|
796
|
+
@_builtins.property
|
|
520
797
|
@pulumi.getter(name="memoryPerUnit")
|
|
521
|
-
def memory_per_unit(self) -> Optional[pulumi.Input[int]]:
|
|
798
|
+
def memory_per_unit(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
799
|
+
"""
|
|
800
|
+
RAM units for compute.
|
|
801
|
+
"""
|
|
522
802
|
return pulumi.get(self, "memory_per_unit")
|
|
523
803
|
|
|
524
804
|
@memory_per_unit.setter
|
|
525
|
-
def memory_per_unit(self, value: Optional[pulumi.Input[int]]):
|
|
805
|
+
def memory_per_unit(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
526
806
|
pulumi.set(self, "memory_per_unit", value)
|
|
527
807
|
|
|
528
|
-
@property
|
|
808
|
+
@_builtins.property
|
|
529
809
|
@pulumi.getter(name="numOfUnits")
|
|
530
|
-
def num_of_units(self) -> Optional[pulumi.Input[int]]:
|
|
810
|
+
def num_of_units(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
811
|
+
"""
|
|
812
|
+
Amount of units for compute.
|
|
813
|
+
"""
|
|
531
814
|
return pulumi.get(self, "num_of_units")
|
|
532
815
|
|
|
533
816
|
@num_of_units.setter
|
|
534
|
-
def num_of_units(self, value: Optional[pulumi.Input[int]]):
|
|
817
|
+
def num_of_units(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
535
818
|
pulumi.set(self, "num_of_units", value)
|
|
536
819
|
|
|
537
820
|
|
|
821
|
+
if not MYPY:
|
|
822
|
+
class ElastigroupIntegrationGkeAutoscaleLabelArgsDict(TypedDict):
|
|
823
|
+
key: pulumi.Input[_builtins.str]
|
|
824
|
+
value: pulumi.Input[_builtins.str]
|
|
825
|
+
elif False:
|
|
826
|
+
ElastigroupIntegrationGkeAutoscaleLabelArgsDict: TypeAlias = Mapping[str, Any]
|
|
827
|
+
|
|
538
828
|
@pulumi.input_type
|
|
539
829
|
class ElastigroupIntegrationGkeAutoscaleLabelArgs:
|
|
540
830
|
def __init__(__self__, *,
|
|
541
|
-
key: pulumi.Input[str],
|
|
542
|
-
value: pulumi.Input[str]):
|
|
831
|
+
key: pulumi.Input[_builtins.str],
|
|
832
|
+
value: pulumi.Input[_builtins.str]):
|
|
543
833
|
pulumi.set(__self__, "key", key)
|
|
544
834
|
pulumi.set(__self__, "value", value)
|
|
545
835
|
|
|
546
|
-
@property
|
|
836
|
+
@_builtins.property
|
|
547
837
|
@pulumi.getter
|
|
548
|
-
def key(self) -> pulumi.Input[str]:
|
|
838
|
+
def key(self) -> pulumi.Input[_builtins.str]:
|
|
549
839
|
return pulumi.get(self, "key")
|
|
550
840
|
|
|
551
841
|
@key.setter
|
|
552
|
-
def key(self, value: pulumi.Input[str]):
|
|
842
|
+
def key(self, value: pulumi.Input[_builtins.str]):
|
|
553
843
|
pulumi.set(self, "key", value)
|
|
554
844
|
|
|
555
|
-
@property
|
|
845
|
+
@_builtins.property
|
|
556
846
|
@pulumi.getter
|
|
557
|
-
def value(self) -> pulumi.Input[str]:
|
|
847
|
+
def value(self) -> pulumi.Input[_builtins.str]:
|
|
558
848
|
return pulumi.get(self, "value")
|
|
559
849
|
|
|
560
850
|
@value.setter
|
|
561
|
-
def value(self, value: pulumi.Input[str]):
|
|
851
|
+
def value(self, value: pulumi.Input[_builtins.str]):
|
|
562
852
|
pulumi.set(self, "value", value)
|
|
563
853
|
|
|
564
854
|
|
|
855
|
+
if not MYPY:
|
|
856
|
+
class ElastigroupLabelArgsDict(TypedDict):
|
|
857
|
+
key: pulumi.Input[_builtins.str]
|
|
858
|
+
value: pulumi.Input[_builtins.str]
|
|
859
|
+
elif False:
|
|
860
|
+
ElastigroupLabelArgsDict: TypeAlias = Mapping[str, Any]
|
|
861
|
+
|
|
565
862
|
@pulumi.input_type
|
|
566
863
|
class ElastigroupLabelArgs:
|
|
567
864
|
def __init__(__self__, *,
|
|
568
|
-
key: pulumi.Input[str],
|
|
569
|
-
value: pulumi.Input[str]):
|
|
865
|
+
key: pulumi.Input[_builtins.str],
|
|
866
|
+
value: pulumi.Input[_builtins.str]):
|
|
570
867
|
pulumi.set(__self__, "key", key)
|
|
571
868
|
pulumi.set(__self__, "value", value)
|
|
572
869
|
|
|
573
|
-
@property
|
|
870
|
+
@_builtins.property
|
|
574
871
|
@pulumi.getter
|
|
575
|
-
def key(self) -> pulumi.Input[str]:
|
|
872
|
+
def key(self) -> pulumi.Input[_builtins.str]:
|
|
576
873
|
return pulumi.get(self, "key")
|
|
577
874
|
|
|
578
875
|
@key.setter
|
|
579
|
-
def key(self, value: pulumi.Input[str]):
|
|
876
|
+
def key(self, value: pulumi.Input[_builtins.str]):
|
|
580
877
|
pulumi.set(self, "key", value)
|
|
581
878
|
|
|
582
|
-
@property
|
|
879
|
+
@_builtins.property
|
|
583
880
|
@pulumi.getter
|
|
584
|
-
def value(self) -> pulumi.Input[str]:
|
|
881
|
+
def value(self) -> pulumi.Input[_builtins.str]:
|
|
585
882
|
return pulumi.get(self, "value")
|
|
586
883
|
|
|
587
884
|
@value.setter
|
|
588
|
-
def value(self, value: pulumi.Input[str]):
|
|
885
|
+
def value(self, value: pulumi.Input[_builtins.str]):
|
|
589
886
|
pulumi.set(self, "value", value)
|
|
590
887
|
|
|
591
888
|
|
|
889
|
+
if not MYPY:
|
|
890
|
+
class ElastigroupMetadataArgsDict(TypedDict):
|
|
891
|
+
key: pulumi.Input[_builtins.str]
|
|
892
|
+
value: pulumi.Input[_builtins.str]
|
|
893
|
+
elif False:
|
|
894
|
+
ElastigroupMetadataArgsDict: TypeAlias = Mapping[str, Any]
|
|
895
|
+
|
|
592
896
|
@pulumi.input_type
|
|
593
897
|
class ElastigroupMetadataArgs:
|
|
594
898
|
def __init__(__self__, *,
|
|
595
|
-
key: pulumi.Input[str],
|
|
596
|
-
value: pulumi.Input[str]):
|
|
899
|
+
key: pulumi.Input[_builtins.str],
|
|
900
|
+
value: pulumi.Input[_builtins.str]):
|
|
597
901
|
pulumi.set(__self__, "key", key)
|
|
598
902
|
pulumi.set(__self__, "value", value)
|
|
599
903
|
|
|
600
|
-
@property
|
|
904
|
+
@_builtins.property
|
|
601
905
|
@pulumi.getter
|
|
602
|
-
def key(self) -> pulumi.Input[str]:
|
|
906
|
+
def key(self) -> pulumi.Input[_builtins.str]:
|
|
603
907
|
return pulumi.get(self, "key")
|
|
604
908
|
|
|
605
909
|
@key.setter
|
|
606
|
-
def key(self, value: pulumi.Input[str]):
|
|
910
|
+
def key(self, value: pulumi.Input[_builtins.str]):
|
|
607
911
|
pulumi.set(self, "key", value)
|
|
608
912
|
|
|
609
|
-
@property
|
|
913
|
+
@_builtins.property
|
|
610
914
|
@pulumi.getter
|
|
611
|
-
def value(self) -> pulumi.Input[str]:
|
|
915
|
+
def value(self) -> pulumi.Input[_builtins.str]:
|
|
612
916
|
return pulumi.get(self, "value")
|
|
613
917
|
|
|
614
918
|
@value.setter
|
|
615
|
-
def value(self, value: pulumi.Input[str]):
|
|
919
|
+
def value(self, value: pulumi.Input[_builtins.str]):
|
|
616
920
|
pulumi.set(self, "value", value)
|
|
617
921
|
|
|
618
922
|
|
|
923
|
+
if not MYPY:
|
|
924
|
+
class ElastigroupNetworkInterfaceArgsDict(TypedDict):
|
|
925
|
+
network: pulumi.Input[_builtins.str]
|
|
926
|
+
access_configs: NotRequired[pulumi.Input[Sequence[pulumi.Input['ElastigroupNetworkInterfaceAccessConfigArgsDict']]]]
|
|
927
|
+
alias_ip_ranges: NotRequired[pulumi.Input[Sequence[pulumi.Input['ElastigroupNetworkInterfaceAliasIpRangeArgsDict']]]]
|
|
928
|
+
elif False:
|
|
929
|
+
ElastigroupNetworkInterfaceArgsDict: TypeAlias = Mapping[str, Any]
|
|
930
|
+
|
|
619
931
|
@pulumi.input_type
|
|
620
932
|
class ElastigroupNetworkInterfaceArgs:
|
|
621
933
|
def __init__(__self__, *,
|
|
622
|
-
network: pulumi.Input[str],
|
|
934
|
+
network: pulumi.Input[_builtins.str],
|
|
623
935
|
access_configs: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupNetworkInterfaceAccessConfigArgs']]]] = None,
|
|
624
936
|
alias_ip_ranges: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupNetworkInterfaceAliasIpRangeArgs']]]] = None):
|
|
625
937
|
pulumi.set(__self__, "network", network)
|
|
@@ -628,16 +940,16 @@ class ElastigroupNetworkInterfaceArgs:
|
|
|
628
940
|
if alias_ip_ranges is not None:
|
|
629
941
|
pulumi.set(__self__, "alias_ip_ranges", alias_ip_ranges)
|
|
630
942
|
|
|
631
|
-
@property
|
|
943
|
+
@_builtins.property
|
|
632
944
|
@pulumi.getter
|
|
633
|
-
def network(self) -> pulumi.Input[str]:
|
|
945
|
+
def network(self) -> pulumi.Input[_builtins.str]:
|
|
634
946
|
return pulumi.get(self, "network")
|
|
635
947
|
|
|
636
948
|
@network.setter
|
|
637
|
-
def network(self, value: pulumi.Input[str]):
|
|
949
|
+
def network(self, value: pulumi.Input[_builtins.str]):
|
|
638
950
|
pulumi.set(self, "network", value)
|
|
639
951
|
|
|
640
|
-
@property
|
|
952
|
+
@_builtins.property
|
|
641
953
|
@pulumi.getter(name="accessConfigs")
|
|
642
954
|
def access_configs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupNetworkInterfaceAccessConfigArgs']]]]:
|
|
643
955
|
return pulumi.get(self, "access_configs")
|
|
@@ -646,7 +958,7 @@ class ElastigroupNetworkInterfaceArgs:
|
|
|
646
958
|
def access_configs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupNetworkInterfaceAccessConfigArgs']]]]):
|
|
647
959
|
pulumi.set(self, "access_configs", value)
|
|
648
960
|
|
|
649
|
-
@property
|
|
961
|
+
@_builtins.property
|
|
650
962
|
@pulumi.getter(name="aliasIpRanges")
|
|
651
963
|
def alias_ip_ranges(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupNetworkInterfaceAliasIpRangeArgs']]]]:
|
|
652
964
|
return pulumi.get(self, "alias_ip_ranges")
|
|
@@ -656,79 +968,140 @@ class ElastigroupNetworkInterfaceArgs:
|
|
|
656
968
|
pulumi.set(self, "alias_ip_ranges", value)
|
|
657
969
|
|
|
658
970
|
|
|
971
|
+
if not MYPY:
|
|
972
|
+
class ElastigroupNetworkInterfaceAccessConfigArgsDict(TypedDict):
|
|
973
|
+
name: NotRequired[pulumi.Input[_builtins.str]]
|
|
974
|
+
type: NotRequired[pulumi.Input[_builtins.str]]
|
|
975
|
+
elif False:
|
|
976
|
+
ElastigroupNetworkInterfaceAccessConfigArgsDict: TypeAlias = Mapping[str, Any]
|
|
977
|
+
|
|
659
978
|
@pulumi.input_type
|
|
660
979
|
class ElastigroupNetworkInterfaceAccessConfigArgs:
|
|
661
980
|
def __init__(__self__, *,
|
|
662
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
663
|
-
type: Optional[pulumi.Input[str]] = None):
|
|
981
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
982
|
+
type: Optional[pulumi.Input[_builtins.str]] = None):
|
|
664
983
|
if name is not None:
|
|
665
984
|
pulumi.set(__self__, "name", name)
|
|
666
985
|
if type is not None:
|
|
667
986
|
pulumi.set(__self__, "type", type)
|
|
668
987
|
|
|
669
|
-
@property
|
|
988
|
+
@_builtins.property
|
|
670
989
|
@pulumi.getter
|
|
671
|
-
def name(self) -> Optional[pulumi.Input[str]]:
|
|
990
|
+
def name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
672
991
|
return pulumi.get(self, "name")
|
|
673
992
|
|
|
674
993
|
@name.setter
|
|
675
|
-
def name(self, value: Optional[pulumi.Input[str]]):
|
|
994
|
+
def name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
676
995
|
pulumi.set(self, "name", value)
|
|
677
996
|
|
|
678
|
-
@property
|
|
997
|
+
@_builtins.property
|
|
679
998
|
@pulumi.getter
|
|
680
|
-
def type(self) -> Optional[pulumi.Input[str]]:
|
|
999
|
+
def type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
681
1000
|
return pulumi.get(self, "type")
|
|
682
1001
|
|
|
683
1002
|
@type.setter
|
|
684
|
-
def type(self, value: Optional[pulumi.Input[str]]):
|
|
1003
|
+
def type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
685
1004
|
pulumi.set(self, "type", value)
|
|
686
1005
|
|
|
687
1006
|
|
|
1007
|
+
if not MYPY:
|
|
1008
|
+
class ElastigroupNetworkInterfaceAliasIpRangeArgsDict(TypedDict):
|
|
1009
|
+
ip_cidr_range: pulumi.Input[_builtins.str]
|
|
1010
|
+
subnetwork_range_name: pulumi.Input[_builtins.str]
|
|
1011
|
+
elif False:
|
|
1012
|
+
ElastigroupNetworkInterfaceAliasIpRangeArgsDict: TypeAlias = Mapping[str, Any]
|
|
1013
|
+
|
|
688
1014
|
@pulumi.input_type
|
|
689
1015
|
class ElastigroupNetworkInterfaceAliasIpRangeArgs:
|
|
690
1016
|
def __init__(__self__, *,
|
|
691
|
-
ip_cidr_range: pulumi.Input[str],
|
|
692
|
-
subnetwork_range_name: pulumi.Input[str]):
|
|
1017
|
+
ip_cidr_range: pulumi.Input[_builtins.str],
|
|
1018
|
+
subnetwork_range_name: pulumi.Input[_builtins.str]):
|
|
693
1019
|
pulumi.set(__self__, "ip_cidr_range", ip_cidr_range)
|
|
694
1020
|
pulumi.set(__self__, "subnetwork_range_name", subnetwork_range_name)
|
|
695
1021
|
|
|
696
|
-
@property
|
|
1022
|
+
@_builtins.property
|
|
697
1023
|
@pulumi.getter(name="ipCidrRange")
|
|
698
|
-
def ip_cidr_range(self) -> pulumi.Input[str]:
|
|
1024
|
+
def ip_cidr_range(self) -> pulumi.Input[_builtins.str]:
|
|
699
1025
|
return pulumi.get(self, "ip_cidr_range")
|
|
700
1026
|
|
|
701
1027
|
@ip_cidr_range.setter
|
|
702
|
-
def ip_cidr_range(self, value: pulumi.Input[str]):
|
|
1028
|
+
def ip_cidr_range(self, value: pulumi.Input[_builtins.str]):
|
|
703
1029
|
pulumi.set(self, "ip_cidr_range", value)
|
|
704
1030
|
|
|
705
|
-
@property
|
|
1031
|
+
@_builtins.property
|
|
706
1032
|
@pulumi.getter(name="subnetworkRangeName")
|
|
707
|
-
def subnetwork_range_name(self) -> pulumi.Input[str]:
|
|
1033
|
+
def subnetwork_range_name(self) -> pulumi.Input[_builtins.str]:
|
|
708
1034
|
return pulumi.get(self, "subnetwork_range_name")
|
|
709
1035
|
|
|
710
1036
|
@subnetwork_range_name.setter
|
|
711
|
-
def subnetwork_range_name(self, value: pulumi.Input[str]):
|
|
1037
|
+
def subnetwork_range_name(self, value: pulumi.Input[_builtins.str]):
|
|
712
1038
|
pulumi.set(self, "subnetwork_range_name", value)
|
|
713
1039
|
|
|
714
1040
|
|
|
1041
|
+
if not MYPY:
|
|
1042
|
+
class ElastigroupRevertToPreemptibleArgsDict(TypedDict):
|
|
1043
|
+
perform_at: pulumi.Input[_builtins.str]
|
|
1044
|
+
elif False:
|
|
1045
|
+
ElastigroupRevertToPreemptibleArgsDict: TypeAlias = Mapping[str, Any]
|
|
1046
|
+
|
|
1047
|
+
@pulumi.input_type
|
|
1048
|
+
class ElastigroupRevertToPreemptibleArgs:
|
|
1049
|
+
def __init__(__self__, *,
|
|
1050
|
+
perform_at: pulumi.Input[_builtins.str]):
|
|
1051
|
+
pulumi.set(__self__, "perform_at", perform_at)
|
|
1052
|
+
|
|
1053
|
+
@_builtins.property
|
|
1054
|
+
@pulumi.getter(name="performAt")
|
|
1055
|
+
def perform_at(self) -> pulumi.Input[_builtins.str]:
|
|
1056
|
+
return pulumi.get(self, "perform_at")
|
|
1057
|
+
|
|
1058
|
+
@perform_at.setter
|
|
1059
|
+
def perform_at(self, value: pulumi.Input[_builtins.str]):
|
|
1060
|
+
pulumi.set(self, "perform_at", value)
|
|
1061
|
+
|
|
1062
|
+
|
|
1063
|
+
if not MYPY:
|
|
1064
|
+
class ElastigroupScalingDownPolicyArgsDict(TypedDict):
|
|
1065
|
+
metric_name: pulumi.Input[_builtins.str]
|
|
1066
|
+
namespace: pulumi.Input[_builtins.str]
|
|
1067
|
+
policy_name: pulumi.Input[_builtins.str]
|
|
1068
|
+
threshold: pulumi.Input[_builtins.float]
|
|
1069
|
+
unit: pulumi.Input[_builtins.str]
|
|
1070
|
+
action_type: NotRequired[pulumi.Input[_builtins.str]]
|
|
1071
|
+
adjustment: NotRequired[pulumi.Input[_builtins.int]]
|
|
1072
|
+
cooldown: NotRequired[pulumi.Input[_builtins.int]]
|
|
1073
|
+
dimensions: NotRequired[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingDownPolicyDimensionArgsDict']]]]
|
|
1074
|
+
evaluation_periods: NotRequired[pulumi.Input[_builtins.int]]
|
|
1075
|
+
"""
|
|
1076
|
+
Amount of cooldown evaluation periods for scale down.
|
|
1077
|
+
"""
|
|
1078
|
+
operator: NotRequired[pulumi.Input[_builtins.str]]
|
|
1079
|
+
period: NotRequired[pulumi.Input[_builtins.int]]
|
|
1080
|
+
source: NotRequired[pulumi.Input[_builtins.str]]
|
|
1081
|
+
statistic: NotRequired[pulumi.Input[_builtins.str]]
|
|
1082
|
+
elif False:
|
|
1083
|
+
ElastigroupScalingDownPolicyArgsDict: TypeAlias = Mapping[str, Any]
|
|
1084
|
+
|
|
715
1085
|
@pulumi.input_type
|
|
716
1086
|
class ElastigroupScalingDownPolicyArgs:
|
|
717
1087
|
def __init__(__self__, *,
|
|
718
|
-
metric_name: pulumi.Input[str],
|
|
719
|
-
namespace: pulumi.Input[str],
|
|
720
|
-
policy_name: pulumi.Input[str],
|
|
721
|
-
threshold: pulumi.Input[float],
|
|
722
|
-
unit: pulumi.Input[str],
|
|
723
|
-
action_type: Optional[pulumi.Input[str]] = None,
|
|
724
|
-
adjustment: Optional[pulumi.Input[int]] = None,
|
|
725
|
-
cooldown: Optional[pulumi.Input[int]] = None,
|
|
1088
|
+
metric_name: pulumi.Input[_builtins.str],
|
|
1089
|
+
namespace: pulumi.Input[_builtins.str],
|
|
1090
|
+
policy_name: pulumi.Input[_builtins.str],
|
|
1091
|
+
threshold: pulumi.Input[_builtins.float],
|
|
1092
|
+
unit: pulumi.Input[_builtins.str],
|
|
1093
|
+
action_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1094
|
+
adjustment: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1095
|
+
cooldown: Optional[pulumi.Input[_builtins.int]] = None,
|
|
726
1096
|
dimensions: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingDownPolicyDimensionArgs']]]] = None,
|
|
727
|
-
evaluation_periods: Optional[pulumi.Input[int]] = None,
|
|
728
|
-
operator: Optional[pulumi.Input[str]] = None,
|
|
729
|
-
period: Optional[pulumi.Input[int]] = None,
|
|
730
|
-
source: Optional[pulumi.Input[str]] = None,
|
|
731
|
-
statistic: Optional[pulumi.Input[str]] = None):
|
|
1097
|
+
evaluation_periods: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1098
|
+
operator: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1099
|
+
period: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1100
|
+
source: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1101
|
+
statistic: Optional[pulumi.Input[_builtins.str]] = None):
|
|
1102
|
+
"""
|
|
1103
|
+
:param pulumi.Input[_builtins.int] evaluation_periods: Amount of cooldown evaluation periods for scale down.
|
|
1104
|
+
"""
|
|
732
1105
|
pulumi.set(__self__, "metric_name", metric_name)
|
|
733
1106
|
pulumi.set(__self__, "namespace", namespace)
|
|
734
1107
|
pulumi.set(__self__, "policy_name", policy_name)
|
|
@@ -753,79 +1126,79 @@ class ElastigroupScalingDownPolicyArgs:
|
|
|
753
1126
|
if statistic is not None:
|
|
754
1127
|
pulumi.set(__self__, "statistic", statistic)
|
|
755
1128
|
|
|
756
|
-
@property
|
|
1129
|
+
@_builtins.property
|
|
757
1130
|
@pulumi.getter(name="metricName")
|
|
758
|
-
def metric_name(self) -> pulumi.Input[str]:
|
|
1131
|
+
def metric_name(self) -> pulumi.Input[_builtins.str]:
|
|
759
1132
|
return pulumi.get(self, "metric_name")
|
|
760
1133
|
|
|
761
1134
|
@metric_name.setter
|
|
762
|
-
def metric_name(self, value: pulumi.Input[str]):
|
|
1135
|
+
def metric_name(self, value: pulumi.Input[_builtins.str]):
|
|
763
1136
|
pulumi.set(self, "metric_name", value)
|
|
764
1137
|
|
|
765
|
-
@property
|
|
1138
|
+
@_builtins.property
|
|
766
1139
|
@pulumi.getter
|
|
767
|
-
def namespace(self) -> pulumi.Input[str]:
|
|
1140
|
+
def namespace(self) -> pulumi.Input[_builtins.str]:
|
|
768
1141
|
return pulumi.get(self, "namespace")
|
|
769
1142
|
|
|
770
1143
|
@namespace.setter
|
|
771
|
-
def namespace(self, value: pulumi.Input[str]):
|
|
1144
|
+
def namespace(self, value: pulumi.Input[_builtins.str]):
|
|
772
1145
|
pulumi.set(self, "namespace", value)
|
|
773
1146
|
|
|
774
|
-
@property
|
|
1147
|
+
@_builtins.property
|
|
775
1148
|
@pulumi.getter(name="policyName")
|
|
776
|
-
def policy_name(self) -> pulumi.Input[str]:
|
|
1149
|
+
def policy_name(self) -> pulumi.Input[_builtins.str]:
|
|
777
1150
|
return pulumi.get(self, "policy_name")
|
|
778
1151
|
|
|
779
1152
|
@policy_name.setter
|
|
780
|
-
def policy_name(self, value: pulumi.Input[str]):
|
|
1153
|
+
def policy_name(self, value: pulumi.Input[_builtins.str]):
|
|
781
1154
|
pulumi.set(self, "policy_name", value)
|
|
782
1155
|
|
|
783
|
-
@property
|
|
1156
|
+
@_builtins.property
|
|
784
1157
|
@pulumi.getter
|
|
785
|
-
def threshold(self) -> pulumi.Input[float]:
|
|
1158
|
+
def threshold(self) -> pulumi.Input[_builtins.float]:
|
|
786
1159
|
return pulumi.get(self, "threshold")
|
|
787
1160
|
|
|
788
1161
|
@threshold.setter
|
|
789
|
-
def threshold(self, value: pulumi.Input[float]):
|
|
1162
|
+
def threshold(self, value: pulumi.Input[_builtins.float]):
|
|
790
1163
|
pulumi.set(self, "threshold", value)
|
|
791
1164
|
|
|
792
|
-
@property
|
|
1165
|
+
@_builtins.property
|
|
793
1166
|
@pulumi.getter
|
|
794
|
-
def unit(self) -> pulumi.Input[str]:
|
|
1167
|
+
def unit(self) -> pulumi.Input[_builtins.str]:
|
|
795
1168
|
return pulumi.get(self, "unit")
|
|
796
1169
|
|
|
797
1170
|
@unit.setter
|
|
798
|
-
def unit(self, value: pulumi.Input[str]):
|
|
1171
|
+
def unit(self, value: pulumi.Input[_builtins.str]):
|
|
799
1172
|
pulumi.set(self, "unit", value)
|
|
800
1173
|
|
|
801
|
-
@property
|
|
1174
|
+
@_builtins.property
|
|
802
1175
|
@pulumi.getter(name="actionType")
|
|
803
|
-
def action_type(self) -> Optional[pulumi.Input[str]]:
|
|
1176
|
+
def action_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
804
1177
|
return pulumi.get(self, "action_type")
|
|
805
1178
|
|
|
806
1179
|
@action_type.setter
|
|
807
|
-
def action_type(self, value: Optional[pulumi.Input[str]]):
|
|
1180
|
+
def action_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
808
1181
|
pulumi.set(self, "action_type", value)
|
|
809
1182
|
|
|
810
|
-
@property
|
|
1183
|
+
@_builtins.property
|
|
811
1184
|
@pulumi.getter
|
|
812
|
-
def adjustment(self) -> Optional[pulumi.Input[int]]:
|
|
1185
|
+
def adjustment(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
813
1186
|
return pulumi.get(self, "adjustment")
|
|
814
1187
|
|
|
815
1188
|
@adjustment.setter
|
|
816
|
-
def adjustment(self, value: Optional[pulumi.Input[int]]):
|
|
1189
|
+
def adjustment(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
817
1190
|
pulumi.set(self, "adjustment", value)
|
|
818
1191
|
|
|
819
|
-
@property
|
|
1192
|
+
@_builtins.property
|
|
820
1193
|
@pulumi.getter
|
|
821
|
-
def cooldown(self) -> Optional[pulumi.Input[int]]:
|
|
1194
|
+
def cooldown(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
822
1195
|
return pulumi.get(self, "cooldown")
|
|
823
1196
|
|
|
824
1197
|
@cooldown.setter
|
|
825
|
-
def cooldown(self, value: Optional[pulumi.Input[int]]):
|
|
1198
|
+
def cooldown(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
826
1199
|
pulumi.set(self, "cooldown", value)
|
|
827
1200
|
|
|
828
|
-
@property
|
|
1201
|
+
@_builtins.property
|
|
829
1202
|
@pulumi.getter
|
|
830
1203
|
def dimensions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingDownPolicyDimensionArgs']]]]:
|
|
831
1204
|
return pulumi.get(self, "dimensions")
|
|
@@ -834,97 +1207,132 @@ class ElastigroupScalingDownPolicyArgs:
|
|
|
834
1207
|
def dimensions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingDownPolicyDimensionArgs']]]]):
|
|
835
1208
|
pulumi.set(self, "dimensions", value)
|
|
836
1209
|
|
|
837
|
-
@property
|
|
1210
|
+
@_builtins.property
|
|
838
1211
|
@pulumi.getter(name="evaluationPeriods")
|
|
839
|
-
def evaluation_periods(self) -> Optional[pulumi.Input[int]]:
|
|
1212
|
+
def evaluation_periods(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1213
|
+
"""
|
|
1214
|
+
Amount of cooldown evaluation periods for scale down.
|
|
1215
|
+
"""
|
|
840
1216
|
return pulumi.get(self, "evaluation_periods")
|
|
841
1217
|
|
|
842
1218
|
@evaluation_periods.setter
|
|
843
|
-
def evaluation_periods(self, value: Optional[pulumi.Input[int]]):
|
|
1219
|
+
def evaluation_periods(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
844
1220
|
pulumi.set(self, "evaluation_periods", value)
|
|
845
1221
|
|
|
846
|
-
@property
|
|
1222
|
+
@_builtins.property
|
|
847
1223
|
@pulumi.getter
|
|
848
|
-
def operator(self) -> Optional[pulumi.Input[str]]:
|
|
1224
|
+
def operator(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
849
1225
|
return pulumi.get(self, "operator")
|
|
850
1226
|
|
|
851
1227
|
@operator.setter
|
|
852
|
-
def operator(self, value: Optional[pulumi.Input[str]]):
|
|
1228
|
+
def operator(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
853
1229
|
pulumi.set(self, "operator", value)
|
|
854
1230
|
|
|
855
|
-
@property
|
|
1231
|
+
@_builtins.property
|
|
856
1232
|
@pulumi.getter
|
|
857
|
-
def period(self) -> Optional[pulumi.Input[int]]:
|
|
1233
|
+
def period(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
858
1234
|
return pulumi.get(self, "period")
|
|
859
1235
|
|
|
860
1236
|
@period.setter
|
|
861
|
-
def period(self, value: Optional[pulumi.Input[int]]):
|
|
1237
|
+
def period(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
862
1238
|
pulumi.set(self, "period", value)
|
|
863
1239
|
|
|
864
|
-
@property
|
|
1240
|
+
@_builtins.property
|
|
865
1241
|
@pulumi.getter
|
|
866
|
-
def source(self) -> Optional[pulumi.Input[str]]:
|
|
1242
|
+
def source(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
867
1243
|
return pulumi.get(self, "source")
|
|
868
1244
|
|
|
869
1245
|
@source.setter
|
|
870
|
-
def source(self, value: Optional[pulumi.Input[str]]):
|
|
1246
|
+
def source(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
871
1247
|
pulumi.set(self, "source", value)
|
|
872
1248
|
|
|
873
|
-
@property
|
|
1249
|
+
@_builtins.property
|
|
874
1250
|
@pulumi.getter
|
|
875
|
-
def statistic(self) -> Optional[pulumi.Input[str]]:
|
|
1251
|
+
def statistic(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
876
1252
|
return pulumi.get(self, "statistic")
|
|
877
1253
|
|
|
878
1254
|
@statistic.setter
|
|
879
|
-
def statistic(self, value: Optional[pulumi.Input[str]]):
|
|
1255
|
+
def statistic(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
880
1256
|
pulumi.set(self, "statistic", value)
|
|
881
1257
|
|
|
882
1258
|
|
|
1259
|
+
if not MYPY:
|
|
1260
|
+
class ElastigroupScalingDownPolicyDimensionArgsDict(TypedDict):
|
|
1261
|
+
name: pulumi.Input[_builtins.str]
|
|
1262
|
+
value: NotRequired[pulumi.Input[_builtins.str]]
|
|
1263
|
+
elif False:
|
|
1264
|
+
ElastigroupScalingDownPolicyDimensionArgsDict: TypeAlias = Mapping[str, Any]
|
|
1265
|
+
|
|
883
1266
|
@pulumi.input_type
|
|
884
1267
|
class ElastigroupScalingDownPolicyDimensionArgs:
|
|
885
1268
|
def __init__(__self__, *,
|
|
886
|
-
name: pulumi.Input[str],
|
|
887
|
-
value: Optional[pulumi.Input[str]] = None):
|
|
1269
|
+
name: pulumi.Input[_builtins.str],
|
|
1270
|
+
value: Optional[pulumi.Input[_builtins.str]] = None):
|
|
888
1271
|
pulumi.set(__self__, "name", name)
|
|
889
1272
|
if value is not None:
|
|
890
1273
|
pulumi.set(__self__, "value", value)
|
|
891
1274
|
|
|
892
|
-
@property
|
|
1275
|
+
@_builtins.property
|
|
893
1276
|
@pulumi.getter
|
|
894
|
-
def name(self) -> pulumi.Input[str]:
|
|
1277
|
+
def name(self) -> pulumi.Input[_builtins.str]:
|
|
895
1278
|
return pulumi.get(self, "name")
|
|
896
1279
|
|
|
897
1280
|
@name.setter
|
|
898
|
-
def name(self, value: pulumi.Input[str]):
|
|
1281
|
+
def name(self, value: pulumi.Input[_builtins.str]):
|
|
899
1282
|
pulumi.set(self, "name", value)
|
|
900
1283
|
|
|
901
|
-
@property
|
|
1284
|
+
@_builtins.property
|
|
902
1285
|
@pulumi.getter
|
|
903
|
-
def value(self) -> Optional[pulumi.Input[str]]:
|
|
1286
|
+
def value(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
904
1287
|
return pulumi.get(self, "value")
|
|
905
1288
|
|
|
906
1289
|
@value.setter
|
|
907
|
-
def value(self, value: Optional[pulumi.Input[str]]):
|
|
1290
|
+
def value(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
908
1291
|
pulumi.set(self, "value", value)
|
|
909
1292
|
|
|
910
1293
|
|
|
1294
|
+
if not MYPY:
|
|
1295
|
+
class ElastigroupScalingUpPolicyArgsDict(TypedDict):
|
|
1296
|
+
metric_name: pulumi.Input[_builtins.str]
|
|
1297
|
+
namespace: pulumi.Input[_builtins.str]
|
|
1298
|
+
policy_name: pulumi.Input[_builtins.str]
|
|
1299
|
+
threshold: pulumi.Input[_builtins.float]
|
|
1300
|
+
unit: pulumi.Input[_builtins.str]
|
|
1301
|
+
action_type: NotRequired[pulumi.Input[_builtins.str]]
|
|
1302
|
+
adjustment: NotRequired[pulumi.Input[_builtins.int]]
|
|
1303
|
+
cooldown: NotRequired[pulumi.Input[_builtins.int]]
|
|
1304
|
+
dimensions: NotRequired[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingUpPolicyDimensionArgsDict']]]]
|
|
1305
|
+
evaluation_periods: NotRequired[pulumi.Input[_builtins.int]]
|
|
1306
|
+
"""
|
|
1307
|
+
Amount of cooldown evaluation periods for scale down.
|
|
1308
|
+
"""
|
|
1309
|
+
operator: NotRequired[pulumi.Input[_builtins.str]]
|
|
1310
|
+
period: NotRequired[pulumi.Input[_builtins.int]]
|
|
1311
|
+
source: NotRequired[pulumi.Input[_builtins.str]]
|
|
1312
|
+
statistic: NotRequired[pulumi.Input[_builtins.str]]
|
|
1313
|
+
elif False:
|
|
1314
|
+
ElastigroupScalingUpPolicyArgsDict: TypeAlias = Mapping[str, Any]
|
|
1315
|
+
|
|
911
1316
|
@pulumi.input_type
|
|
912
1317
|
class ElastigroupScalingUpPolicyArgs:
|
|
913
1318
|
def __init__(__self__, *,
|
|
914
|
-
metric_name: pulumi.Input[str],
|
|
915
|
-
namespace: pulumi.Input[str],
|
|
916
|
-
policy_name: pulumi.Input[str],
|
|
917
|
-
threshold: pulumi.Input[float],
|
|
918
|
-
unit: pulumi.Input[str],
|
|
919
|
-
action_type: Optional[pulumi.Input[str]] = None,
|
|
920
|
-
adjustment: Optional[pulumi.Input[int]] = None,
|
|
921
|
-
cooldown: Optional[pulumi.Input[int]] = None,
|
|
1319
|
+
metric_name: pulumi.Input[_builtins.str],
|
|
1320
|
+
namespace: pulumi.Input[_builtins.str],
|
|
1321
|
+
policy_name: pulumi.Input[_builtins.str],
|
|
1322
|
+
threshold: pulumi.Input[_builtins.float],
|
|
1323
|
+
unit: pulumi.Input[_builtins.str],
|
|
1324
|
+
action_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1325
|
+
adjustment: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1326
|
+
cooldown: Optional[pulumi.Input[_builtins.int]] = None,
|
|
922
1327
|
dimensions: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingUpPolicyDimensionArgs']]]] = None,
|
|
923
|
-
evaluation_periods: Optional[pulumi.Input[int]] = None,
|
|
924
|
-
operator: Optional[pulumi.Input[str]] = None,
|
|
925
|
-
period: Optional[pulumi.Input[int]] = None,
|
|
926
|
-
source: Optional[pulumi.Input[str]] = None,
|
|
927
|
-
statistic: Optional[pulumi.Input[str]] = None):
|
|
1328
|
+
evaluation_periods: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1329
|
+
operator: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1330
|
+
period: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1331
|
+
source: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1332
|
+
statistic: Optional[pulumi.Input[_builtins.str]] = None):
|
|
1333
|
+
"""
|
|
1334
|
+
:param pulumi.Input[_builtins.int] evaluation_periods: Amount of cooldown evaluation periods for scale down.
|
|
1335
|
+
"""
|
|
928
1336
|
pulumi.set(__self__, "metric_name", metric_name)
|
|
929
1337
|
pulumi.set(__self__, "namespace", namespace)
|
|
930
1338
|
pulumi.set(__self__, "policy_name", policy_name)
|
|
@@ -949,79 +1357,79 @@ class ElastigroupScalingUpPolicyArgs:
|
|
|
949
1357
|
if statistic is not None:
|
|
950
1358
|
pulumi.set(__self__, "statistic", statistic)
|
|
951
1359
|
|
|
952
|
-
@property
|
|
1360
|
+
@_builtins.property
|
|
953
1361
|
@pulumi.getter(name="metricName")
|
|
954
|
-
def metric_name(self) -> pulumi.Input[str]:
|
|
1362
|
+
def metric_name(self) -> pulumi.Input[_builtins.str]:
|
|
955
1363
|
return pulumi.get(self, "metric_name")
|
|
956
1364
|
|
|
957
1365
|
@metric_name.setter
|
|
958
|
-
def metric_name(self, value: pulumi.Input[str]):
|
|
1366
|
+
def metric_name(self, value: pulumi.Input[_builtins.str]):
|
|
959
1367
|
pulumi.set(self, "metric_name", value)
|
|
960
1368
|
|
|
961
|
-
@property
|
|
1369
|
+
@_builtins.property
|
|
962
1370
|
@pulumi.getter
|
|
963
|
-
def namespace(self) -> pulumi.Input[str]:
|
|
1371
|
+
def namespace(self) -> pulumi.Input[_builtins.str]:
|
|
964
1372
|
return pulumi.get(self, "namespace")
|
|
965
1373
|
|
|
966
1374
|
@namespace.setter
|
|
967
|
-
def namespace(self, value: pulumi.Input[str]):
|
|
1375
|
+
def namespace(self, value: pulumi.Input[_builtins.str]):
|
|
968
1376
|
pulumi.set(self, "namespace", value)
|
|
969
1377
|
|
|
970
|
-
@property
|
|
1378
|
+
@_builtins.property
|
|
971
1379
|
@pulumi.getter(name="policyName")
|
|
972
|
-
def policy_name(self) -> pulumi.Input[str]:
|
|
1380
|
+
def policy_name(self) -> pulumi.Input[_builtins.str]:
|
|
973
1381
|
return pulumi.get(self, "policy_name")
|
|
974
1382
|
|
|
975
1383
|
@policy_name.setter
|
|
976
|
-
def policy_name(self, value: pulumi.Input[str]):
|
|
1384
|
+
def policy_name(self, value: pulumi.Input[_builtins.str]):
|
|
977
1385
|
pulumi.set(self, "policy_name", value)
|
|
978
1386
|
|
|
979
|
-
@property
|
|
1387
|
+
@_builtins.property
|
|
980
1388
|
@pulumi.getter
|
|
981
|
-
def threshold(self) -> pulumi.Input[float]:
|
|
1389
|
+
def threshold(self) -> pulumi.Input[_builtins.float]:
|
|
982
1390
|
return pulumi.get(self, "threshold")
|
|
983
1391
|
|
|
984
1392
|
@threshold.setter
|
|
985
|
-
def threshold(self, value: pulumi.Input[float]):
|
|
1393
|
+
def threshold(self, value: pulumi.Input[_builtins.float]):
|
|
986
1394
|
pulumi.set(self, "threshold", value)
|
|
987
1395
|
|
|
988
|
-
@property
|
|
1396
|
+
@_builtins.property
|
|
989
1397
|
@pulumi.getter
|
|
990
|
-
def unit(self) -> pulumi.Input[str]:
|
|
1398
|
+
def unit(self) -> pulumi.Input[_builtins.str]:
|
|
991
1399
|
return pulumi.get(self, "unit")
|
|
992
1400
|
|
|
993
1401
|
@unit.setter
|
|
994
|
-
def unit(self, value: pulumi.Input[str]):
|
|
1402
|
+
def unit(self, value: pulumi.Input[_builtins.str]):
|
|
995
1403
|
pulumi.set(self, "unit", value)
|
|
996
1404
|
|
|
997
|
-
@property
|
|
1405
|
+
@_builtins.property
|
|
998
1406
|
@pulumi.getter(name="actionType")
|
|
999
|
-
def action_type(self) -> Optional[pulumi.Input[str]]:
|
|
1407
|
+
def action_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1000
1408
|
return pulumi.get(self, "action_type")
|
|
1001
1409
|
|
|
1002
1410
|
@action_type.setter
|
|
1003
|
-
def action_type(self, value: Optional[pulumi.Input[str]]):
|
|
1411
|
+
def action_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1004
1412
|
pulumi.set(self, "action_type", value)
|
|
1005
1413
|
|
|
1006
|
-
@property
|
|
1414
|
+
@_builtins.property
|
|
1007
1415
|
@pulumi.getter
|
|
1008
|
-
def adjustment(self) -> Optional[pulumi.Input[int]]:
|
|
1416
|
+
def adjustment(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1009
1417
|
return pulumi.get(self, "adjustment")
|
|
1010
1418
|
|
|
1011
1419
|
@adjustment.setter
|
|
1012
|
-
def adjustment(self, value: Optional[pulumi.Input[int]]):
|
|
1420
|
+
def adjustment(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1013
1421
|
pulumi.set(self, "adjustment", value)
|
|
1014
1422
|
|
|
1015
|
-
@property
|
|
1423
|
+
@_builtins.property
|
|
1016
1424
|
@pulumi.getter
|
|
1017
|
-
def cooldown(self) -> Optional[pulumi.Input[int]]:
|
|
1425
|
+
def cooldown(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1018
1426
|
return pulumi.get(self, "cooldown")
|
|
1019
1427
|
|
|
1020
1428
|
@cooldown.setter
|
|
1021
|
-
def cooldown(self, value: Optional[pulumi.Input[int]]):
|
|
1429
|
+
def cooldown(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1022
1430
|
pulumi.set(self, "cooldown", value)
|
|
1023
1431
|
|
|
1024
|
-
@property
|
|
1432
|
+
@_builtins.property
|
|
1025
1433
|
@pulumi.getter
|
|
1026
1434
|
def dimensions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingUpPolicyDimensionArgs']]]]:
|
|
1027
1435
|
return pulumi.get(self, "dimensions")
|
|
@@ -1030,99 +1438,214 @@ class ElastigroupScalingUpPolicyArgs:
|
|
|
1030
1438
|
def dimensions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingUpPolicyDimensionArgs']]]]):
|
|
1031
1439
|
pulumi.set(self, "dimensions", value)
|
|
1032
1440
|
|
|
1033
|
-
@property
|
|
1441
|
+
@_builtins.property
|
|
1034
1442
|
@pulumi.getter(name="evaluationPeriods")
|
|
1035
|
-
def evaluation_periods(self) -> Optional[pulumi.Input[int]]:
|
|
1443
|
+
def evaluation_periods(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1444
|
+
"""
|
|
1445
|
+
Amount of cooldown evaluation periods for scale down.
|
|
1446
|
+
"""
|
|
1036
1447
|
return pulumi.get(self, "evaluation_periods")
|
|
1037
1448
|
|
|
1038
1449
|
@evaluation_periods.setter
|
|
1039
|
-
def evaluation_periods(self, value: Optional[pulumi.Input[int]]):
|
|
1450
|
+
def evaluation_periods(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1040
1451
|
pulumi.set(self, "evaluation_periods", value)
|
|
1041
1452
|
|
|
1042
|
-
@property
|
|
1453
|
+
@_builtins.property
|
|
1043
1454
|
@pulumi.getter
|
|
1044
|
-
def operator(self) -> Optional[pulumi.Input[str]]:
|
|
1455
|
+
def operator(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1045
1456
|
return pulumi.get(self, "operator")
|
|
1046
1457
|
|
|
1047
1458
|
@operator.setter
|
|
1048
|
-
def operator(self, value: Optional[pulumi.Input[str]]):
|
|
1459
|
+
def operator(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1049
1460
|
pulumi.set(self, "operator", value)
|
|
1050
1461
|
|
|
1051
|
-
@property
|
|
1462
|
+
@_builtins.property
|
|
1052
1463
|
@pulumi.getter
|
|
1053
|
-
def period(self) -> Optional[pulumi.Input[int]]:
|
|
1464
|
+
def period(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1054
1465
|
return pulumi.get(self, "period")
|
|
1055
1466
|
|
|
1056
1467
|
@period.setter
|
|
1057
|
-
def period(self, value: Optional[pulumi.Input[int]]):
|
|
1468
|
+
def period(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1058
1469
|
pulumi.set(self, "period", value)
|
|
1059
1470
|
|
|
1060
|
-
@property
|
|
1471
|
+
@_builtins.property
|
|
1061
1472
|
@pulumi.getter
|
|
1062
|
-
def source(self) -> Optional[pulumi.Input[str]]:
|
|
1473
|
+
def source(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1063
1474
|
return pulumi.get(self, "source")
|
|
1064
1475
|
|
|
1065
1476
|
@source.setter
|
|
1066
|
-
def source(self, value: Optional[pulumi.Input[str]]):
|
|
1477
|
+
def source(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1067
1478
|
pulumi.set(self, "source", value)
|
|
1068
1479
|
|
|
1069
|
-
@property
|
|
1480
|
+
@_builtins.property
|
|
1070
1481
|
@pulumi.getter
|
|
1071
|
-
def statistic(self) -> Optional[pulumi.Input[str]]:
|
|
1482
|
+
def statistic(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1072
1483
|
return pulumi.get(self, "statistic")
|
|
1073
1484
|
|
|
1074
1485
|
@statistic.setter
|
|
1075
|
-
def statistic(self, value: Optional[pulumi.Input[str]]):
|
|
1486
|
+
def statistic(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1076
1487
|
pulumi.set(self, "statistic", value)
|
|
1077
1488
|
|
|
1078
1489
|
|
|
1490
|
+
if not MYPY:
|
|
1491
|
+
class ElastigroupScalingUpPolicyDimensionArgsDict(TypedDict):
|
|
1492
|
+
name: pulumi.Input[_builtins.str]
|
|
1493
|
+
value: NotRequired[pulumi.Input[_builtins.str]]
|
|
1494
|
+
elif False:
|
|
1495
|
+
ElastigroupScalingUpPolicyDimensionArgsDict: TypeAlias = Mapping[str, Any]
|
|
1496
|
+
|
|
1079
1497
|
@pulumi.input_type
|
|
1080
1498
|
class ElastigroupScalingUpPolicyDimensionArgs:
|
|
1081
1499
|
def __init__(__self__, *,
|
|
1082
|
-
name: pulumi.Input[str],
|
|
1083
|
-
value: Optional[pulumi.Input[str]] = None):
|
|
1500
|
+
name: pulumi.Input[_builtins.str],
|
|
1501
|
+
value: Optional[pulumi.Input[_builtins.str]] = None):
|
|
1084
1502
|
pulumi.set(__self__, "name", name)
|
|
1085
1503
|
if value is not None:
|
|
1086
1504
|
pulumi.set(__self__, "value", value)
|
|
1087
1505
|
|
|
1088
|
-
@property
|
|
1506
|
+
@_builtins.property
|
|
1089
1507
|
@pulumi.getter
|
|
1090
|
-
def name(self) -> pulumi.Input[str]:
|
|
1508
|
+
def name(self) -> pulumi.Input[_builtins.str]:
|
|
1091
1509
|
return pulumi.get(self, "name")
|
|
1092
1510
|
|
|
1093
1511
|
@name.setter
|
|
1094
|
-
def name(self, value: pulumi.Input[str]):
|
|
1512
|
+
def name(self, value: pulumi.Input[_builtins.str]):
|
|
1095
1513
|
pulumi.set(self, "name", value)
|
|
1096
1514
|
|
|
1097
|
-
@property
|
|
1515
|
+
@_builtins.property
|
|
1098
1516
|
@pulumi.getter
|
|
1099
|
-
def value(self) -> Optional[pulumi.Input[str]]:
|
|
1517
|
+
def value(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1100
1518
|
return pulumi.get(self, "value")
|
|
1101
1519
|
|
|
1102
1520
|
@value.setter
|
|
1103
|
-
def value(self, value: Optional[pulumi.Input[str]]):
|
|
1521
|
+
def value(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1104
1522
|
pulumi.set(self, "value", value)
|
|
1105
1523
|
|
|
1106
1524
|
|
|
1525
|
+
if not MYPY:
|
|
1526
|
+
class ElastigroupShieldedInstanceConfigArgsDict(TypedDict):
|
|
1527
|
+
enable_integrity_monitoring: NotRequired[pulumi.Input[_builtins.bool]]
|
|
1528
|
+
enable_secure_boot: NotRequired[pulumi.Input[_builtins.bool]]
|
|
1529
|
+
elif False:
|
|
1530
|
+
ElastigroupShieldedInstanceConfigArgsDict: TypeAlias = Mapping[str, Any]
|
|
1531
|
+
|
|
1532
|
+
@pulumi.input_type
|
|
1533
|
+
class ElastigroupShieldedInstanceConfigArgs:
|
|
1534
|
+
def __init__(__self__, *,
|
|
1535
|
+
enable_integrity_monitoring: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1536
|
+
enable_secure_boot: Optional[pulumi.Input[_builtins.bool]] = None):
|
|
1537
|
+
if enable_integrity_monitoring is not None:
|
|
1538
|
+
pulumi.set(__self__, "enable_integrity_monitoring", enable_integrity_monitoring)
|
|
1539
|
+
if enable_secure_boot is not None:
|
|
1540
|
+
pulumi.set(__self__, "enable_secure_boot", enable_secure_boot)
|
|
1541
|
+
|
|
1542
|
+
@_builtins.property
|
|
1543
|
+
@pulumi.getter(name="enableIntegrityMonitoring")
|
|
1544
|
+
def enable_integrity_monitoring(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1545
|
+
return pulumi.get(self, "enable_integrity_monitoring")
|
|
1546
|
+
|
|
1547
|
+
@enable_integrity_monitoring.setter
|
|
1548
|
+
def enable_integrity_monitoring(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1549
|
+
pulumi.set(self, "enable_integrity_monitoring", value)
|
|
1550
|
+
|
|
1551
|
+
@_builtins.property
|
|
1552
|
+
@pulumi.getter(name="enableSecureBoot")
|
|
1553
|
+
def enable_secure_boot(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1554
|
+
return pulumi.get(self, "enable_secure_boot")
|
|
1555
|
+
|
|
1556
|
+
@enable_secure_boot.setter
|
|
1557
|
+
def enable_secure_boot(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1558
|
+
pulumi.set(self, "enable_secure_boot", value)
|
|
1559
|
+
|
|
1560
|
+
|
|
1561
|
+
if not MYPY:
|
|
1562
|
+
class OceanImportAutoUpdateArgsDict(TypedDict):
|
|
1563
|
+
is_enabled: NotRequired[pulumi.Input[_builtins.bool]]
|
|
1564
|
+
"""
|
|
1565
|
+
Enable the Ocean Kubernetes AutoUpdate.
|
|
1566
|
+
"""
|
|
1567
|
+
elif False:
|
|
1568
|
+
OceanImportAutoUpdateArgsDict: TypeAlias = Mapping[str, Any]
|
|
1569
|
+
|
|
1570
|
+
@pulumi.input_type
|
|
1571
|
+
class OceanImportAutoUpdateArgs:
|
|
1572
|
+
def __init__(__self__, *,
|
|
1573
|
+
is_enabled: Optional[pulumi.Input[_builtins.bool]] = None):
|
|
1574
|
+
"""
|
|
1575
|
+
:param pulumi.Input[_builtins.bool] is_enabled: Enable the Ocean Kubernetes AutoUpdate.
|
|
1576
|
+
"""
|
|
1577
|
+
if is_enabled is not None:
|
|
1578
|
+
pulumi.set(__self__, "is_enabled", is_enabled)
|
|
1579
|
+
|
|
1580
|
+
@_builtins.property
|
|
1581
|
+
@pulumi.getter(name="isEnabled")
|
|
1582
|
+
def is_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1583
|
+
"""
|
|
1584
|
+
Enable the Ocean Kubernetes AutoUpdate.
|
|
1585
|
+
"""
|
|
1586
|
+
return pulumi.get(self, "is_enabled")
|
|
1587
|
+
|
|
1588
|
+
@is_enabled.setter
|
|
1589
|
+
def is_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1590
|
+
pulumi.set(self, "is_enabled", value)
|
|
1591
|
+
|
|
1592
|
+
|
|
1593
|
+
if not MYPY:
|
|
1594
|
+
class OceanImportAutoscalerArgsDict(TypedDict):
|
|
1595
|
+
auto_headroom_percentage: NotRequired[pulumi.Input[_builtins.int]]
|
|
1596
|
+
"""
|
|
1597
|
+
Optionally set the auto headroom percentage, set a number between 0-200 to control the headroom % from the cluster. Relevant when isAutoConfig=true.
|
|
1598
|
+
"""
|
|
1599
|
+
cooldown: NotRequired[pulumi.Input[_builtins.int]]
|
|
1600
|
+
"""
|
|
1601
|
+
Cooldown period between scaling actions.
|
|
1602
|
+
"""
|
|
1603
|
+
down: NotRequired[pulumi.Input['OceanImportAutoscalerDownArgsDict']]
|
|
1604
|
+
"""
|
|
1605
|
+
Auto Scaling scale down operations.
|
|
1606
|
+
"""
|
|
1607
|
+
enable_automatic_and_manual_headroom: NotRequired[pulumi.Input[_builtins.bool]]
|
|
1608
|
+
"""
|
|
1609
|
+
enables automatic and manual headroom to work in parallel. When set to false, automatic headroom overrides all other headroom definitions manually configured, whether they are at cluster or VNG level.
|
|
1610
|
+
"""
|
|
1611
|
+
headroom: NotRequired[pulumi.Input['OceanImportAutoscalerHeadroomArgsDict']]
|
|
1612
|
+
"""
|
|
1613
|
+
Spare resource capacity management enabling fast assignment of Pods without waiting for new resources to launch.
|
|
1614
|
+
"""
|
|
1615
|
+
is_auto_config: NotRequired[pulumi.Input[_builtins.bool]]
|
|
1616
|
+
"""
|
|
1617
|
+
Automatically configure and optimize headroom resources.
|
|
1618
|
+
"""
|
|
1619
|
+
is_enabled: NotRequired[pulumi.Input[_builtins.bool]]
|
|
1620
|
+
"""
|
|
1621
|
+
Enable the Ocean Kubernetes Autoscaler.
|
|
1622
|
+
"""
|
|
1623
|
+
resource_limits: NotRequired[pulumi.Input['OceanImportAutoscalerResourceLimitsArgsDict']]
|
|
1624
|
+
"""
|
|
1625
|
+
Optionally set upper and lower bounds on the resource usage of the cluster.
|
|
1626
|
+
"""
|
|
1627
|
+
elif False:
|
|
1628
|
+
OceanImportAutoscalerArgsDict: TypeAlias = Mapping[str, Any]
|
|
1629
|
+
|
|
1107
1630
|
@pulumi.input_type
|
|
1108
1631
|
class OceanImportAutoscalerArgs:
|
|
1109
1632
|
def __init__(__self__, *,
|
|
1110
|
-
auto_headroom_percentage: Optional[pulumi.Input[int]] = None,
|
|
1111
|
-
cooldown: Optional[pulumi.Input[int]] = None,
|
|
1633
|
+
auto_headroom_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1634
|
+
cooldown: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1112
1635
|
down: Optional[pulumi.Input['OceanImportAutoscalerDownArgs']] = None,
|
|
1113
|
-
enable_automatic_and_manual_headroom: Optional[pulumi.Input[bool]] = None,
|
|
1636
|
+
enable_automatic_and_manual_headroom: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1114
1637
|
headroom: Optional[pulumi.Input['OceanImportAutoscalerHeadroomArgs']] = None,
|
|
1115
|
-
is_auto_config: Optional[pulumi.Input[bool]] = None,
|
|
1116
|
-
is_enabled: Optional[pulumi.Input[bool]] = None,
|
|
1638
|
+
is_auto_config: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1639
|
+
is_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1117
1640
|
resource_limits: Optional[pulumi.Input['OceanImportAutoscalerResourceLimitsArgs']] = None):
|
|
1118
1641
|
"""
|
|
1119
|
-
:param pulumi.Input[int] auto_headroom_percentage: Optionally set the auto headroom percentage, set a number between 0-200 to control the headroom % from the cluster. Relevant when isAutoConfig=true.
|
|
1120
|
-
:param pulumi.Input[int] cooldown: Cooldown period between scaling actions.
|
|
1642
|
+
:param pulumi.Input[_builtins.int] auto_headroom_percentage: Optionally set the auto headroom percentage, set a number between 0-200 to control the headroom % from the cluster. Relevant when isAutoConfig=true.
|
|
1643
|
+
:param pulumi.Input[_builtins.int] cooldown: Cooldown period between scaling actions.
|
|
1121
1644
|
:param pulumi.Input['OceanImportAutoscalerDownArgs'] down: Auto Scaling scale down operations.
|
|
1122
|
-
:param pulumi.Input[bool] enable_automatic_and_manual_headroom: enables automatic and manual headroom to work in parallel. When set to false, automatic headroom overrides all other headroom definitions manually configured, whether they are at cluster or VNG level.
|
|
1645
|
+
:param pulumi.Input[_builtins.bool] enable_automatic_and_manual_headroom: enables automatic and manual headroom to work in parallel. When set to false, automatic headroom overrides all other headroom definitions manually configured, whether they are at cluster or VNG level.
|
|
1123
1646
|
:param pulumi.Input['OceanImportAutoscalerHeadroomArgs'] headroom: Spare resource capacity management enabling fast assignment of Pods without waiting for new resources to launch.
|
|
1124
|
-
:param pulumi.Input[bool] is_auto_config: Automatically configure and optimize headroom resources.
|
|
1125
|
-
:param pulumi.Input[bool] is_enabled: Enable the Ocean Kubernetes Autoscaler.
|
|
1647
|
+
:param pulumi.Input[_builtins.bool] is_auto_config: Automatically configure and optimize headroom resources.
|
|
1648
|
+
:param pulumi.Input[_builtins.bool] is_enabled: Enable the Ocean Kubernetes Autoscaler.
|
|
1126
1649
|
:param pulumi.Input['OceanImportAutoscalerResourceLimitsArgs'] resource_limits: Optionally set upper and lower bounds on the resource usage of the cluster.
|
|
1127
1650
|
"""
|
|
1128
1651
|
if auto_headroom_percentage is not None:
|
|
@@ -1142,31 +1665,31 @@ class OceanImportAutoscalerArgs:
|
|
|
1142
1665
|
if resource_limits is not None:
|
|
1143
1666
|
pulumi.set(__self__, "resource_limits", resource_limits)
|
|
1144
1667
|
|
|
1145
|
-
@property
|
|
1668
|
+
@_builtins.property
|
|
1146
1669
|
@pulumi.getter(name="autoHeadroomPercentage")
|
|
1147
|
-
def auto_headroom_percentage(self) -> Optional[pulumi.Input[int]]:
|
|
1670
|
+
def auto_headroom_percentage(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1148
1671
|
"""
|
|
1149
1672
|
Optionally set the auto headroom percentage, set a number between 0-200 to control the headroom % from the cluster. Relevant when isAutoConfig=true.
|
|
1150
1673
|
"""
|
|
1151
1674
|
return pulumi.get(self, "auto_headroom_percentage")
|
|
1152
1675
|
|
|
1153
1676
|
@auto_headroom_percentage.setter
|
|
1154
|
-
def auto_headroom_percentage(self, value: Optional[pulumi.Input[int]]):
|
|
1677
|
+
def auto_headroom_percentage(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1155
1678
|
pulumi.set(self, "auto_headroom_percentage", value)
|
|
1156
1679
|
|
|
1157
|
-
@property
|
|
1680
|
+
@_builtins.property
|
|
1158
1681
|
@pulumi.getter
|
|
1159
|
-
def cooldown(self) -> Optional[pulumi.Input[int]]:
|
|
1682
|
+
def cooldown(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1160
1683
|
"""
|
|
1161
1684
|
Cooldown period between scaling actions.
|
|
1162
1685
|
"""
|
|
1163
1686
|
return pulumi.get(self, "cooldown")
|
|
1164
1687
|
|
|
1165
1688
|
@cooldown.setter
|
|
1166
|
-
def cooldown(self, value: Optional[pulumi.Input[int]]):
|
|
1689
|
+
def cooldown(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1167
1690
|
pulumi.set(self, "cooldown", value)
|
|
1168
1691
|
|
|
1169
|
-
@property
|
|
1692
|
+
@_builtins.property
|
|
1170
1693
|
@pulumi.getter
|
|
1171
1694
|
def down(self) -> Optional[pulumi.Input['OceanImportAutoscalerDownArgs']]:
|
|
1172
1695
|
"""
|
|
@@ -1178,19 +1701,19 @@ class OceanImportAutoscalerArgs:
|
|
|
1178
1701
|
def down(self, value: Optional[pulumi.Input['OceanImportAutoscalerDownArgs']]):
|
|
1179
1702
|
pulumi.set(self, "down", value)
|
|
1180
1703
|
|
|
1181
|
-
@property
|
|
1704
|
+
@_builtins.property
|
|
1182
1705
|
@pulumi.getter(name="enableAutomaticAndManualHeadroom")
|
|
1183
|
-
def enable_automatic_and_manual_headroom(self) -> Optional[pulumi.Input[bool]]:
|
|
1706
|
+
def enable_automatic_and_manual_headroom(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1184
1707
|
"""
|
|
1185
1708
|
enables automatic and manual headroom to work in parallel. When set to false, automatic headroom overrides all other headroom definitions manually configured, whether they are at cluster or VNG level.
|
|
1186
1709
|
"""
|
|
1187
1710
|
return pulumi.get(self, "enable_automatic_and_manual_headroom")
|
|
1188
1711
|
|
|
1189
1712
|
@enable_automatic_and_manual_headroom.setter
|
|
1190
|
-
def enable_automatic_and_manual_headroom(self, value: Optional[pulumi.Input[bool]]):
|
|
1713
|
+
def enable_automatic_and_manual_headroom(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1191
1714
|
pulumi.set(self, "enable_automatic_and_manual_headroom", value)
|
|
1192
1715
|
|
|
1193
|
-
@property
|
|
1716
|
+
@_builtins.property
|
|
1194
1717
|
@pulumi.getter
|
|
1195
1718
|
def headroom(self) -> Optional[pulumi.Input['OceanImportAutoscalerHeadroomArgs']]:
|
|
1196
1719
|
"""
|
|
@@ -1202,31 +1725,31 @@ class OceanImportAutoscalerArgs:
|
|
|
1202
1725
|
def headroom(self, value: Optional[pulumi.Input['OceanImportAutoscalerHeadroomArgs']]):
|
|
1203
1726
|
pulumi.set(self, "headroom", value)
|
|
1204
1727
|
|
|
1205
|
-
@property
|
|
1728
|
+
@_builtins.property
|
|
1206
1729
|
@pulumi.getter(name="isAutoConfig")
|
|
1207
|
-
def is_auto_config(self) -> Optional[pulumi.Input[bool]]:
|
|
1730
|
+
def is_auto_config(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1208
1731
|
"""
|
|
1209
1732
|
Automatically configure and optimize headroom resources.
|
|
1210
1733
|
"""
|
|
1211
1734
|
return pulumi.get(self, "is_auto_config")
|
|
1212
1735
|
|
|
1213
1736
|
@is_auto_config.setter
|
|
1214
|
-
def is_auto_config(self, value: Optional[pulumi.Input[bool]]):
|
|
1737
|
+
def is_auto_config(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1215
1738
|
pulumi.set(self, "is_auto_config", value)
|
|
1216
1739
|
|
|
1217
|
-
@property
|
|
1740
|
+
@_builtins.property
|
|
1218
1741
|
@pulumi.getter(name="isEnabled")
|
|
1219
|
-
def is_enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
1742
|
+
def is_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1220
1743
|
"""
|
|
1221
1744
|
Enable the Ocean Kubernetes Autoscaler.
|
|
1222
1745
|
"""
|
|
1223
1746
|
return pulumi.get(self, "is_enabled")
|
|
1224
1747
|
|
|
1225
1748
|
@is_enabled.setter
|
|
1226
|
-
def is_enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
1749
|
+
def is_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1227
1750
|
pulumi.set(self, "is_enabled", value)
|
|
1228
1751
|
|
|
1229
|
-
@property
|
|
1752
|
+
@_builtins.property
|
|
1230
1753
|
@pulumi.getter(name="resourceLimits")
|
|
1231
1754
|
def resource_limits(self) -> Optional[pulumi.Input['OceanImportAutoscalerResourceLimitsArgs']]:
|
|
1232
1755
|
"""
|
|
@@ -1239,57 +1762,111 @@ class OceanImportAutoscalerArgs:
|
|
|
1239
1762
|
pulumi.set(self, "resource_limits", value)
|
|
1240
1763
|
|
|
1241
1764
|
|
|
1765
|
+
if not MYPY:
|
|
1766
|
+
class OceanImportAutoscalerDownArgsDict(TypedDict):
|
|
1767
|
+
evaluation_periods: NotRequired[pulumi.Input[_builtins.int]]
|
|
1768
|
+
"""
|
|
1769
|
+
The number of evaluation periods that should accumulate before a scale down action takes place.
|
|
1770
|
+
"""
|
|
1771
|
+
is_aggressive_scale_down_enabled: NotRequired[pulumi.Input[_builtins.bool]]
|
|
1772
|
+
"""
|
|
1773
|
+
When set to 'true', the Aggressive Scale Down feature is enabled.
|
|
1774
|
+
"""
|
|
1775
|
+
max_scale_down_percentage: NotRequired[pulumi.Input[_builtins.float]]
|
|
1776
|
+
"""
|
|
1777
|
+
Would represent the maximum % to scale-down. Number between 1-100.
|
|
1778
|
+
"""
|
|
1779
|
+
elif False:
|
|
1780
|
+
OceanImportAutoscalerDownArgsDict: TypeAlias = Mapping[str, Any]
|
|
1781
|
+
|
|
1242
1782
|
@pulumi.input_type
|
|
1243
1783
|
class OceanImportAutoscalerDownArgs:
|
|
1244
1784
|
def __init__(__self__, *,
|
|
1245
|
-
evaluation_periods: Optional[pulumi.Input[int]] = None,
|
|
1246
|
-
|
|
1785
|
+
evaluation_periods: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1786
|
+
is_aggressive_scale_down_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1787
|
+
max_scale_down_percentage: Optional[pulumi.Input[_builtins.float]] = None):
|
|
1247
1788
|
"""
|
|
1248
|
-
:param pulumi.Input[int] evaluation_periods: The number of evaluation periods that should accumulate before a scale down action takes place.
|
|
1249
|
-
:param pulumi.Input[
|
|
1789
|
+
:param pulumi.Input[_builtins.int] evaluation_periods: The number of evaluation periods that should accumulate before a scale down action takes place.
|
|
1790
|
+
:param pulumi.Input[_builtins.bool] is_aggressive_scale_down_enabled: When set to 'true', the Aggressive Scale Down feature is enabled.
|
|
1791
|
+
:param pulumi.Input[_builtins.float] max_scale_down_percentage: Would represent the maximum % to scale-down. Number between 1-100.
|
|
1250
1792
|
"""
|
|
1251
1793
|
if evaluation_periods is not None:
|
|
1252
1794
|
pulumi.set(__self__, "evaluation_periods", evaluation_periods)
|
|
1795
|
+
if is_aggressive_scale_down_enabled is not None:
|
|
1796
|
+
pulumi.set(__self__, "is_aggressive_scale_down_enabled", is_aggressive_scale_down_enabled)
|
|
1253
1797
|
if max_scale_down_percentage is not None:
|
|
1254
1798
|
pulumi.set(__self__, "max_scale_down_percentage", max_scale_down_percentage)
|
|
1255
1799
|
|
|
1256
|
-
@property
|
|
1800
|
+
@_builtins.property
|
|
1257
1801
|
@pulumi.getter(name="evaluationPeriods")
|
|
1258
|
-
def evaluation_periods(self) -> Optional[pulumi.Input[int]]:
|
|
1802
|
+
def evaluation_periods(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1259
1803
|
"""
|
|
1260
1804
|
The number of evaluation periods that should accumulate before a scale down action takes place.
|
|
1261
1805
|
"""
|
|
1262
1806
|
return pulumi.get(self, "evaluation_periods")
|
|
1263
1807
|
|
|
1264
1808
|
@evaluation_periods.setter
|
|
1265
|
-
def evaluation_periods(self, value: Optional[pulumi.Input[int]]):
|
|
1809
|
+
def evaluation_periods(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1266
1810
|
pulumi.set(self, "evaluation_periods", value)
|
|
1267
1811
|
|
|
1268
|
-
@property
|
|
1812
|
+
@_builtins.property
|
|
1813
|
+
@pulumi.getter(name="isAggressiveScaleDownEnabled")
|
|
1814
|
+
def is_aggressive_scale_down_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1815
|
+
"""
|
|
1816
|
+
When set to 'true', the Aggressive Scale Down feature is enabled.
|
|
1817
|
+
"""
|
|
1818
|
+
return pulumi.get(self, "is_aggressive_scale_down_enabled")
|
|
1819
|
+
|
|
1820
|
+
@is_aggressive_scale_down_enabled.setter
|
|
1821
|
+
def is_aggressive_scale_down_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1822
|
+
pulumi.set(self, "is_aggressive_scale_down_enabled", value)
|
|
1823
|
+
|
|
1824
|
+
@_builtins.property
|
|
1269
1825
|
@pulumi.getter(name="maxScaleDownPercentage")
|
|
1270
|
-
def max_scale_down_percentage(self) -> Optional[pulumi.Input[float]]:
|
|
1826
|
+
def max_scale_down_percentage(self) -> Optional[pulumi.Input[_builtins.float]]:
|
|
1271
1827
|
"""
|
|
1272
1828
|
Would represent the maximum % to scale-down. Number between 1-100.
|
|
1273
1829
|
"""
|
|
1274
1830
|
return pulumi.get(self, "max_scale_down_percentage")
|
|
1275
1831
|
|
|
1276
1832
|
@max_scale_down_percentage.setter
|
|
1277
|
-
def max_scale_down_percentage(self, value: Optional[pulumi.Input[float]]):
|
|
1833
|
+
def max_scale_down_percentage(self, value: Optional[pulumi.Input[_builtins.float]]):
|
|
1278
1834
|
pulumi.set(self, "max_scale_down_percentage", value)
|
|
1279
1835
|
|
|
1280
1836
|
|
|
1837
|
+
if not MYPY:
|
|
1838
|
+
class OceanImportAutoscalerHeadroomArgsDict(TypedDict):
|
|
1839
|
+
cpu_per_unit: NotRequired[pulumi.Input[_builtins.int]]
|
|
1840
|
+
"""
|
|
1841
|
+
Optionally configure the number of CPUs to allocate the headroom. CPUs are denoted in millicores, where 1000 millicores = 1 vCPU.
|
|
1842
|
+
"""
|
|
1843
|
+
gpu_per_unit: NotRequired[pulumi.Input[_builtins.int]]
|
|
1844
|
+
"""
|
|
1845
|
+
How much GPU allocate for headroom unit.
|
|
1846
|
+
"""
|
|
1847
|
+
memory_per_unit: NotRequired[pulumi.Input[_builtins.int]]
|
|
1848
|
+
"""
|
|
1849
|
+
Optionally configure the amount of memory (MiB) to allocate the headroom.
|
|
1850
|
+
"""
|
|
1851
|
+
num_of_units: NotRequired[pulumi.Input[_builtins.int]]
|
|
1852
|
+
"""
|
|
1853
|
+
The number of units to retain as headroom, where each unit has the defined headroom CPU and memory.
|
|
1854
|
+
"""
|
|
1855
|
+
elif False:
|
|
1856
|
+
OceanImportAutoscalerHeadroomArgsDict: TypeAlias = Mapping[str, Any]
|
|
1857
|
+
|
|
1281
1858
|
@pulumi.input_type
|
|
1282
1859
|
class OceanImportAutoscalerHeadroomArgs:
|
|
1283
1860
|
def __init__(__self__, *,
|
|
1284
|
-
cpu_per_unit: Optional[pulumi.Input[int]] = None,
|
|
1285
|
-
gpu_per_unit: Optional[pulumi.Input[int]] = None,
|
|
1286
|
-
memory_per_unit: Optional[pulumi.Input[int]] = None,
|
|
1287
|
-
num_of_units: Optional[pulumi.Input[int]] = None):
|
|
1861
|
+
cpu_per_unit: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1862
|
+
gpu_per_unit: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1863
|
+
memory_per_unit: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1864
|
+
num_of_units: Optional[pulumi.Input[_builtins.int]] = None):
|
|
1288
1865
|
"""
|
|
1289
|
-
:param pulumi.Input[int] cpu_per_unit: Optionally configure the number of CPUs to allocate the headroom. CPUs are denoted in millicores, where 1000 millicores = 1 vCPU.
|
|
1290
|
-
:param pulumi.Input[int] gpu_per_unit: How much GPU allocate for headroom unit.
|
|
1291
|
-
:param pulumi.Input[int] memory_per_unit: Optionally configure the amount of memory (MiB) to allocate the headroom.
|
|
1292
|
-
: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.
|
|
1866
|
+
:param pulumi.Input[_builtins.int] cpu_per_unit: Optionally configure the number of CPUs to allocate the headroom. CPUs are denoted in millicores, where 1000 millicores = 1 vCPU.
|
|
1867
|
+
:param pulumi.Input[_builtins.int] gpu_per_unit: How much GPU allocate for headroom unit.
|
|
1868
|
+
:param pulumi.Input[_builtins.int] memory_per_unit: Optionally configure the amount of memory (MiB) to allocate the headroom.
|
|
1869
|
+
: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.
|
|
1293
1870
|
"""
|
|
1294
1871
|
if cpu_per_unit is not None:
|
|
1295
1872
|
pulumi.set(__self__, "cpu_per_unit", cpu_per_unit)
|
|
@@ -1300,105 +1877,136 @@ class OceanImportAutoscalerHeadroomArgs:
|
|
|
1300
1877
|
if num_of_units is not None:
|
|
1301
1878
|
pulumi.set(__self__, "num_of_units", num_of_units)
|
|
1302
1879
|
|
|
1303
|
-
@property
|
|
1880
|
+
@_builtins.property
|
|
1304
1881
|
@pulumi.getter(name="cpuPerUnit")
|
|
1305
|
-
def cpu_per_unit(self) -> Optional[pulumi.Input[int]]:
|
|
1882
|
+
def cpu_per_unit(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1306
1883
|
"""
|
|
1307
1884
|
Optionally configure the number of CPUs to allocate the headroom. CPUs are denoted in millicores, where 1000 millicores = 1 vCPU.
|
|
1308
1885
|
"""
|
|
1309
1886
|
return pulumi.get(self, "cpu_per_unit")
|
|
1310
1887
|
|
|
1311
1888
|
@cpu_per_unit.setter
|
|
1312
|
-
def cpu_per_unit(self, value: Optional[pulumi.Input[int]]):
|
|
1889
|
+
def cpu_per_unit(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1313
1890
|
pulumi.set(self, "cpu_per_unit", value)
|
|
1314
1891
|
|
|
1315
|
-
@property
|
|
1892
|
+
@_builtins.property
|
|
1316
1893
|
@pulumi.getter(name="gpuPerUnit")
|
|
1317
|
-
def gpu_per_unit(self) -> Optional[pulumi.Input[int]]:
|
|
1894
|
+
def gpu_per_unit(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1318
1895
|
"""
|
|
1319
1896
|
How much GPU allocate for headroom unit.
|
|
1320
1897
|
"""
|
|
1321
1898
|
return pulumi.get(self, "gpu_per_unit")
|
|
1322
1899
|
|
|
1323
1900
|
@gpu_per_unit.setter
|
|
1324
|
-
def gpu_per_unit(self, value: Optional[pulumi.Input[int]]):
|
|
1901
|
+
def gpu_per_unit(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1325
1902
|
pulumi.set(self, "gpu_per_unit", value)
|
|
1326
1903
|
|
|
1327
|
-
@property
|
|
1904
|
+
@_builtins.property
|
|
1328
1905
|
@pulumi.getter(name="memoryPerUnit")
|
|
1329
|
-
def memory_per_unit(self) -> Optional[pulumi.Input[int]]:
|
|
1906
|
+
def memory_per_unit(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1330
1907
|
"""
|
|
1331
1908
|
Optionally configure the amount of memory (MiB) to allocate the headroom.
|
|
1332
1909
|
"""
|
|
1333
1910
|
return pulumi.get(self, "memory_per_unit")
|
|
1334
1911
|
|
|
1335
1912
|
@memory_per_unit.setter
|
|
1336
|
-
def memory_per_unit(self, value: Optional[pulumi.Input[int]]):
|
|
1913
|
+
def memory_per_unit(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1337
1914
|
pulumi.set(self, "memory_per_unit", value)
|
|
1338
1915
|
|
|
1339
|
-
@property
|
|
1916
|
+
@_builtins.property
|
|
1340
1917
|
@pulumi.getter(name="numOfUnits")
|
|
1341
|
-
def num_of_units(self) -> Optional[pulumi.Input[int]]:
|
|
1918
|
+
def num_of_units(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1342
1919
|
"""
|
|
1343
1920
|
The number of units to retain as headroom, where each unit has the defined headroom CPU and memory.
|
|
1344
1921
|
"""
|
|
1345
1922
|
return pulumi.get(self, "num_of_units")
|
|
1346
1923
|
|
|
1347
1924
|
@num_of_units.setter
|
|
1348
|
-
def num_of_units(self, value: Optional[pulumi.Input[int]]):
|
|
1925
|
+
def num_of_units(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1349
1926
|
pulumi.set(self, "num_of_units", value)
|
|
1350
1927
|
|
|
1351
1928
|
|
|
1929
|
+
if not MYPY:
|
|
1930
|
+
class OceanImportAutoscalerResourceLimitsArgsDict(TypedDict):
|
|
1931
|
+
max_memory_gib: NotRequired[pulumi.Input[_builtins.int]]
|
|
1932
|
+
"""
|
|
1933
|
+
The maximum memory in GiB units that can be allocated to the cluster.
|
|
1934
|
+
"""
|
|
1935
|
+
max_vcpu: NotRequired[pulumi.Input[_builtins.int]]
|
|
1936
|
+
"""
|
|
1937
|
+
The maximum cpu in vCpu units that can be allocated to the cluster.
|
|
1938
|
+
"""
|
|
1939
|
+
elif False:
|
|
1940
|
+
OceanImportAutoscalerResourceLimitsArgsDict: TypeAlias = Mapping[str, Any]
|
|
1941
|
+
|
|
1352
1942
|
@pulumi.input_type
|
|
1353
1943
|
class OceanImportAutoscalerResourceLimitsArgs:
|
|
1354
1944
|
def __init__(__self__, *,
|
|
1355
|
-
max_memory_gib: Optional[pulumi.Input[int]] = None,
|
|
1356
|
-
max_vcpu: Optional[pulumi.Input[int]] = None):
|
|
1945
|
+
max_memory_gib: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1946
|
+
max_vcpu: Optional[pulumi.Input[_builtins.int]] = None):
|
|
1357
1947
|
"""
|
|
1358
|
-
:param pulumi.Input[int] max_memory_gib: The maximum memory in GiB units that can be allocated to the cluster.
|
|
1359
|
-
:param pulumi.Input[int] max_vcpu: The maximum cpu in vCpu units that can be allocated to the cluster.
|
|
1948
|
+
:param pulumi.Input[_builtins.int] max_memory_gib: The maximum memory in GiB units that can be allocated to the cluster.
|
|
1949
|
+
:param pulumi.Input[_builtins.int] max_vcpu: The maximum cpu in vCpu units that can be allocated to the cluster.
|
|
1360
1950
|
"""
|
|
1361
1951
|
if max_memory_gib is not None:
|
|
1362
1952
|
pulumi.set(__self__, "max_memory_gib", max_memory_gib)
|
|
1363
1953
|
if max_vcpu is not None:
|
|
1364
1954
|
pulumi.set(__self__, "max_vcpu", max_vcpu)
|
|
1365
1955
|
|
|
1366
|
-
@property
|
|
1956
|
+
@_builtins.property
|
|
1367
1957
|
@pulumi.getter(name="maxMemoryGib")
|
|
1368
|
-
def max_memory_gib(self) -> Optional[pulumi.Input[int]]:
|
|
1958
|
+
def max_memory_gib(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1369
1959
|
"""
|
|
1370
1960
|
The maximum memory in GiB units that can be allocated to the cluster.
|
|
1371
1961
|
"""
|
|
1372
1962
|
return pulumi.get(self, "max_memory_gib")
|
|
1373
1963
|
|
|
1374
1964
|
@max_memory_gib.setter
|
|
1375
|
-
def max_memory_gib(self, value: Optional[pulumi.Input[int]]):
|
|
1965
|
+
def max_memory_gib(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1376
1966
|
pulumi.set(self, "max_memory_gib", value)
|
|
1377
1967
|
|
|
1378
|
-
@property
|
|
1968
|
+
@_builtins.property
|
|
1379
1969
|
@pulumi.getter(name="maxVcpu")
|
|
1380
|
-
def max_vcpu(self) -> Optional[pulumi.Input[int]]:
|
|
1970
|
+
def max_vcpu(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1381
1971
|
"""
|
|
1382
1972
|
The maximum cpu in vCpu units that can be allocated to the cluster.
|
|
1383
1973
|
"""
|
|
1384
1974
|
return pulumi.get(self, "max_vcpu")
|
|
1385
1975
|
|
|
1386
1976
|
@max_vcpu.setter
|
|
1387
|
-
def max_vcpu(self, value: Optional[pulumi.Input[int]]):
|
|
1977
|
+
def max_vcpu(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1388
1978
|
pulumi.set(self, "max_vcpu", value)
|
|
1389
1979
|
|
|
1390
1980
|
|
|
1981
|
+
if not MYPY:
|
|
1982
|
+
class OceanImportBackendServiceArgsDict(TypedDict):
|
|
1983
|
+
service_name: pulumi.Input[_builtins.str]
|
|
1984
|
+
"""
|
|
1985
|
+
The name of the backend service.
|
|
1986
|
+
"""
|
|
1987
|
+
location_type: NotRequired[pulumi.Input[_builtins.str]]
|
|
1988
|
+
"""
|
|
1989
|
+
Sets which location the backend services will be active. Valid values: `regional`, `global`.
|
|
1990
|
+
"""
|
|
1991
|
+
named_ports: NotRequired[pulumi.Input[Sequence[pulumi.Input['OceanImportBackendServiceNamedPortArgsDict']]]]
|
|
1992
|
+
scheme: NotRequired[pulumi.Input[_builtins.str]]
|
|
1993
|
+
"""
|
|
1994
|
+
Use when `location_type` is `regional`. Set the traffic for the backend service to either between the instances in the vpc or to traffic from the internet. Valid values: `INTERNAL`, `EXTERNAL`.
|
|
1995
|
+
"""
|
|
1996
|
+
elif False:
|
|
1997
|
+
OceanImportBackendServiceArgsDict: TypeAlias = Mapping[str, Any]
|
|
1998
|
+
|
|
1391
1999
|
@pulumi.input_type
|
|
1392
2000
|
class OceanImportBackendServiceArgs:
|
|
1393
2001
|
def __init__(__self__, *,
|
|
1394
|
-
service_name: pulumi.Input[str],
|
|
1395
|
-
location_type: Optional[pulumi.Input[str]] = None,
|
|
2002
|
+
service_name: pulumi.Input[_builtins.str],
|
|
2003
|
+
location_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1396
2004
|
named_ports: Optional[pulumi.Input[Sequence[pulumi.Input['OceanImportBackendServiceNamedPortArgs']]]] = None,
|
|
1397
|
-
scheme: Optional[pulumi.Input[str]] = None):
|
|
2005
|
+
scheme: Optional[pulumi.Input[_builtins.str]] = None):
|
|
1398
2006
|
"""
|
|
1399
|
-
:param pulumi.Input[str] service_name: The name of the backend service.
|
|
1400
|
-
:param pulumi.Input[str] location_type: Sets which location the backend services will be active. Valid values: `regional`, `global`.
|
|
1401
|
-
:param pulumi.Input[str] scheme: Use when `location_type` is `regional`. Set the traffic for the backend service to either between the instances in the vpc or to traffic from the internet. Valid values: `INTERNAL`, `EXTERNAL`.
|
|
2007
|
+
:param pulumi.Input[_builtins.str] service_name: The name of the backend service.
|
|
2008
|
+
:param pulumi.Input[_builtins.str] location_type: Sets which location the backend services will be active. Valid values: `regional`, `global`.
|
|
2009
|
+
:param pulumi.Input[_builtins.str] scheme: Use when `location_type` is `regional`. Set the traffic for the backend service to either between the instances in the vpc or to traffic from the internet. Valid values: `INTERNAL`, `EXTERNAL`.
|
|
1402
2010
|
"""
|
|
1403
2011
|
pulumi.set(__self__, "service_name", service_name)
|
|
1404
2012
|
if location_type is not None:
|
|
@@ -1408,31 +2016,31 @@ class OceanImportBackendServiceArgs:
|
|
|
1408
2016
|
if scheme is not None:
|
|
1409
2017
|
pulumi.set(__self__, "scheme", scheme)
|
|
1410
2018
|
|
|
1411
|
-
@property
|
|
2019
|
+
@_builtins.property
|
|
1412
2020
|
@pulumi.getter(name="serviceName")
|
|
1413
|
-
def service_name(self) -> pulumi.Input[str]:
|
|
2021
|
+
def service_name(self) -> pulumi.Input[_builtins.str]:
|
|
1414
2022
|
"""
|
|
1415
2023
|
The name of the backend service.
|
|
1416
2024
|
"""
|
|
1417
2025
|
return pulumi.get(self, "service_name")
|
|
1418
2026
|
|
|
1419
2027
|
@service_name.setter
|
|
1420
|
-
def service_name(self, value: pulumi.Input[str]):
|
|
2028
|
+
def service_name(self, value: pulumi.Input[_builtins.str]):
|
|
1421
2029
|
pulumi.set(self, "service_name", value)
|
|
1422
2030
|
|
|
1423
|
-
@property
|
|
2031
|
+
@_builtins.property
|
|
1424
2032
|
@pulumi.getter(name="locationType")
|
|
1425
|
-
def location_type(self) -> Optional[pulumi.Input[str]]:
|
|
2033
|
+
def location_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1426
2034
|
"""
|
|
1427
2035
|
Sets which location the backend services will be active. Valid values: `regional`, `global`.
|
|
1428
2036
|
"""
|
|
1429
2037
|
return pulumi.get(self, "location_type")
|
|
1430
2038
|
|
|
1431
2039
|
@location_type.setter
|
|
1432
|
-
def location_type(self, value: Optional[pulumi.Input[str]]):
|
|
2040
|
+
def location_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1433
2041
|
pulumi.set(self, "location_type", value)
|
|
1434
2042
|
|
|
1435
|
-
@property
|
|
2043
|
+
@_builtins.property
|
|
1436
2044
|
@pulumi.getter(name="namedPorts")
|
|
1437
2045
|
def named_ports(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanImportBackendServiceNamedPortArgs']]]]:
|
|
1438
2046
|
return pulumi.get(self, "named_ports")
|
|
@@ -1441,139 +2049,337 @@ class OceanImportBackendServiceArgs:
|
|
|
1441
2049
|
def named_ports(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanImportBackendServiceNamedPortArgs']]]]):
|
|
1442
2050
|
pulumi.set(self, "named_ports", value)
|
|
1443
2051
|
|
|
1444
|
-
@property
|
|
2052
|
+
@_builtins.property
|
|
1445
2053
|
@pulumi.getter
|
|
1446
|
-
def scheme(self) -> Optional[pulumi.Input[str]]:
|
|
2054
|
+
def scheme(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1447
2055
|
"""
|
|
1448
2056
|
Use when `location_type` is `regional`. Set the traffic for the backend service to either between the instances in the vpc or to traffic from the internet. Valid values: `INTERNAL`, `EXTERNAL`.
|
|
1449
2057
|
"""
|
|
1450
2058
|
return pulumi.get(self, "scheme")
|
|
1451
2059
|
|
|
1452
2060
|
@scheme.setter
|
|
1453
|
-
def scheme(self, value: Optional[pulumi.Input[str]]):
|
|
2061
|
+
def scheme(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1454
2062
|
pulumi.set(self, "scheme", value)
|
|
1455
2063
|
|
|
1456
2064
|
|
|
2065
|
+
if not MYPY:
|
|
2066
|
+
class OceanImportBackendServiceNamedPortArgsDict(TypedDict):
|
|
2067
|
+
name: pulumi.Input[_builtins.str]
|
|
2068
|
+
ports: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]
|
|
2069
|
+
"""
|
|
2070
|
+
A list of ports.
|
|
2071
|
+
"""
|
|
2072
|
+
elif False:
|
|
2073
|
+
OceanImportBackendServiceNamedPortArgsDict: TypeAlias = Mapping[str, Any]
|
|
2074
|
+
|
|
1457
2075
|
@pulumi.input_type
|
|
1458
2076
|
class OceanImportBackendServiceNamedPortArgs:
|
|
1459
2077
|
def __init__(__self__, *,
|
|
1460
|
-
name: pulumi.Input[str],
|
|
1461
|
-
ports: pulumi.Input[Sequence[pulumi.Input[str]]]):
|
|
2078
|
+
name: pulumi.Input[_builtins.str],
|
|
2079
|
+
ports: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]):
|
|
2080
|
+
"""
|
|
2081
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] ports: A list of ports.
|
|
2082
|
+
"""
|
|
1462
2083
|
pulumi.set(__self__, "name", name)
|
|
1463
2084
|
pulumi.set(__self__, "ports", ports)
|
|
1464
2085
|
|
|
1465
|
-
@property
|
|
2086
|
+
@_builtins.property
|
|
1466
2087
|
@pulumi.getter
|
|
1467
|
-
def name(self) -> pulumi.Input[str]:
|
|
2088
|
+
def name(self) -> pulumi.Input[_builtins.str]:
|
|
1468
2089
|
return pulumi.get(self, "name")
|
|
1469
2090
|
|
|
1470
2091
|
@name.setter
|
|
1471
|
-
def name(self, value: pulumi.Input[str]):
|
|
2092
|
+
def name(self, value: pulumi.Input[_builtins.str]):
|
|
1472
2093
|
pulumi.set(self, "name", value)
|
|
1473
2094
|
|
|
1474
|
-
@property
|
|
2095
|
+
@_builtins.property
|
|
1475
2096
|
@pulumi.getter
|
|
1476
|
-
def ports(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
|
|
2097
|
+
def ports(self) -> pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]:
|
|
2098
|
+
"""
|
|
2099
|
+
A list of ports.
|
|
2100
|
+
"""
|
|
1477
2101
|
return pulumi.get(self, "ports")
|
|
1478
2102
|
|
|
1479
2103
|
@ports.setter
|
|
1480
|
-
def ports(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
|
|
2104
|
+
def ports(self, value: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]):
|
|
1481
2105
|
pulumi.set(self, "ports", value)
|
|
1482
2106
|
|
|
1483
2107
|
|
|
1484
|
-
|
|
1485
|
-
class
|
|
1486
|
-
|
|
1487
|
-
shutdown_hours: Optional[pulumi.Input['OceanImportScheduledTaskShutdownHoursArgs']] = None,
|
|
1488
|
-
tasks: Optional[pulumi.Input[Sequence[pulumi.Input['OceanImportScheduledTaskTaskArgs']]]] = None):
|
|
2108
|
+
if not MYPY:
|
|
2109
|
+
class OceanImportFiltersArgsDict(TypedDict):
|
|
2110
|
+
exclude_families: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
1489
2111
|
"""
|
|
1490
|
-
|
|
1491
|
-
:param pulumi.Input[Sequence[pulumi.Input['OceanImportScheduledTaskTaskArgs']]] tasks: The scheduling tasks for the cluster.
|
|
2112
|
+
Types belonging to a family from the ExcludeFamilies will not be available for scaling (asterisk wildcard is also supported). For example, C* will exclude instance types from these families: c5, c4, c4a, etc.
|
|
1492
2113
|
"""
|
|
1493
|
-
|
|
1494
|
-
pulumi.set(__self__, "shutdown_hours", shutdown_hours)
|
|
1495
|
-
if tasks is not None:
|
|
1496
|
-
pulumi.set(__self__, "tasks", tasks)
|
|
1497
|
-
|
|
1498
|
-
@property
|
|
1499
|
-
@pulumi.getter(name="shutdownHours")
|
|
1500
|
-
def shutdown_hours(self) -> Optional[pulumi.Input['OceanImportScheduledTaskShutdownHoursArgs']]:
|
|
2114
|
+
include_families: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
1501
2115
|
"""
|
|
1502
|
-
|
|
2116
|
+
Types belonging to a family from the IncludeFamilies will be available for scaling (asterisk wildcard is also supported). For example, C* will include instance types from these families: c5, c4, c4a, etc.
|
|
1503
2117
|
"""
|
|
1504
|
-
|
|
1505
|
-
|
|
1506
|
-
@shutdown_hours.setter
|
|
1507
|
-
def shutdown_hours(self, value: Optional[pulumi.Input['OceanImportScheduledTaskShutdownHoursArgs']]):
|
|
1508
|
-
pulumi.set(self, "shutdown_hours", value)
|
|
1509
|
-
|
|
1510
|
-
@property
|
|
1511
|
-
@pulumi.getter
|
|
1512
|
-
def tasks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanImportScheduledTaskTaskArgs']]]]:
|
|
2118
|
+
max_memory_gib: NotRequired[pulumi.Input[_builtins.float]]
|
|
1513
2119
|
"""
|
|
1514
|
-
|
|
2120
|
+
Maximum amount of Memory (GiB).
|
|
1515
2121
|
"""
|
|
1516
|
-
|
|
1517
|
-
|
|
1518
|
-
|
|
1519
|
-
|
|
1520
|
-
pulumi.
|
|
1521
|
-
|
|
2122
|
+
max_vcpu: NotRequired[pulumi.Input[_builtins.int]]
|
|
2123
|
+
"""
|
|
2124
|
+
Maximum number of vcpus available.
|
|
2125
|
+
"""
|
|
2126
|
+
min_memory_gib: NotRequired[pulumi.Input[_builtins.float]]
|
|
2127
|
+
"""
|
|
2128
|
+
Minimum amount of Memory (GiB).
|
|
2129
|
+
"""
|
|
2130
|
+
min_vcpu: NotRequired[pulumi.Input[_builtins.int]]
|
|
2131
|
+
"""
|
|
2132
|
+
Minimum number of vcpus available.
|
|
2133
|
+
"""
|
|
2134
|
+
elif False:
|
|
2135
|
+
OceanImportFiltersArgsDict: TypeAlias = Mapping[str, Any]
|
|
1522
2136
|
|
|
1523
2137
|
@pulumi.input_type
|
|
1524
|
-
class
|
|
2138
|
+
class OceanImportFiltersArgs:
|
|
1525
2139
|
def __init__(__self__, *,
|
|
1526
|
-
|
|
1527
|
-
|
|
2140
|
+
exclude_families: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
2141
|
+
include_families: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
2142
|
+
max_memory_gib: Optional[pulumi.Input[_builtins.float]] = None,
|
|
2143
|
+
max_vcpu: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2144
|
+
min_memory_gib: Optional[pulumi.Input[_builtins.float]] = None,
|
|
2145
|
+
min_vcpu: Optional[pulumi.Input[_builtins.int]] = None):
|
|
2146
|
+
"""
|
|
2147
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] exclude_families: Types belonging to a family from the ExcludeFamilies will not be available for scaling (asterisk wildcard is also supported). For example, C* will exclude instance types from these families: c5, c4, c4a, etc.
|
|
2148
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] include_families: Types belonging to a family from the IncludeFamilies will be available for scaling (asterisk wildcard is also supported). For example, C* will include instance types from these families: c5, c4, c4a, etc.
|
|
2149
|
+
:param pulumi.Input[_builtins.float] max_memory_gib: Maximum amount of Memory (GiB).
|
|
2150
|
+
:param pulumi.Input[_builtins.int] max_vcpu: Maximum number of vcpus available.
|
|
2151
|
+
:param pulumi.Input[_builtins.float] min_memory_gib: Minimum amount of Memory (GiB).
|
|
2152
|
+
:param pulumi.Input[_builtins.int] min_vcpu: Minimum number of vcpus available.
|
|
2153
|
+
"""
|
|
2154
|
+
if exclude_families is not None:
|
|
2155
|
+
pulumi.set(__self__, "exclude_families", exclude_families)
|
|
2156
|
+
if include_families is not None:
|
|
2157
|
+
pulumi.set(__self__, "include_families", include_families)
|
|
2158
|
+
if max_memory_gib is not None:
|
|
2159
|
+
pulumi.set(__self__, "max_memory_gib", max_memory_gib)
|
|
2160
|
+
if max_vcpu is not None:
|
|
2161
|
+
pulumi.set(__self__, "max_vcpu", max_vcpu)
|
|
2162
|
+
if min_memory_gib is not None:
|
|
2163
|
+
pulumi.set(__self__, "min_memory_gib", min_memory_gib)
|
|
2164
|
+
if min_vcpu is not None:
|
|
2165
|
+
pulumi.set(__self__, "min_vcpu", min_vcpu)
|
|
2166
|
+
|
|
2167
|
+
@_builtins.property
|
|
2168
|
+
@pulumi.getter(name="excludeFamilies")
|
|
2169
|
+
def exclude_families(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
1528
2170
|
"""
|
|
1529
|
-
|
|
1530
|
-
Example: Fri:15:30-Wed:14:30
|
|
1531
|
-
:param pulumi.Input[bool] is_enabled: Flag to enable / disable the shutdown hours.
|
|
1532
|
-
Example: True
|
|
2171
|
+
Types belonging to a family from the ExcludeFamilies will not be available for scaling (asterisk wildcard is also supported). For example, C* will exclude instance types from these families: c5, c4, c4a, etc.
|
|
1533
2172
|
"""
|
|
1534
|
-
pulumi.
|
|
1535
|
-
if is_enabled is not None:
|
|
1536
|
-
pulumi.set(__self__, "is_enabled", is_enabled)
|
|
2173
|
+
return pulumi.get(self, "exclude_families")
|
|
1537
2174
|
|
|
1538
|
-
@
|
|
1539
|
-
|
|
1540
|
-
|
|
2175
|
+
@exclude_families.setter
|
|
2176
|
+
def exclude_families(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
2177
|
+
pulumi.set(self, "exclude_families", value)
|
|
2178
|
+
|
|
2179
|
+
@_builtins.property
|
|
2180
|
+
@pulumi.getter(name="includeFamilies")
|
|
2181
|
+
def include_families(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
1541
2182
|
"""
|
|
1542
|
-
|
|
1543
|
-
Example: Fri:15:30-Wed:14:30
|
|
2183
|
+
Types belonging to a family from the IncludeFamilies will be available for scaling (asterisk wildcard is also supported). For example, C* will include instance types from these families: c5, c4, c4a, etc.
|
|
1544
2184
|
"""
|
|
1545
|
-
return pulumi.get(self, "
|
|
2185
|
+
return pulumi.get(self, "include_families")
|
|
1546
2186
|
|
|
1547
|
-
@
|
|
1548
|
-
def
|
|
1549
|
-
pulumi.set(self, "
|
|
2187
|
+
@include_families.setter
|
|
2188
|
+
def include_families(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
2189
|
+
pulumi.set(self, "include_families", value)
|
|
1550
2190
|
|
|
1551
|
-
@property
|
|
1552
|
-
@pulumi.getter(name="
|
|
1553
|
-
def
|
|
2191
|
+
@_builtins.property
|
|
2192
|
+
@pulumi.getter(name="maxMemoryGib")
|
|
2193
|
+
def max_memory_gib(self) -> Optional[pulumi.Input[_builtins.float]]:
|
|
1554
2194
|
"""
|
|
1555
|
-
|
|
1556
|
-
Example: True
|
|
2195
|
+
Maximum amount of Memory (GiB).
|
|
1557
2196
|
"""
|
|
1558
|
-
return pulumi.get(self, "
|
|
2197
|
+
return pulumi.get(self, "max_memory_gib")
|
|
1559
2198
|
|
|
1560
|
-
@
|
|
1561
|
-
def
|
|
2199
|
+
@max_memory_gib.setter
|
|
2200
|
+
def max_memory_gib(self, value: Optional[pulumi.Input[_builtins.float]]):
|
|
2201
|
+
pulumi.set(self, "max_memory_gib", value)
|
|
2202
|
+
|
|
2203
|
+
@_builtins.property
|
|
2204
|
+
@pulumi.getter(name="maxVcpu")
|
|
2205
|
+
def max_vcpu(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
2206
|
+
"""
|
|
2207
|
+
Maximum number of vcpus available.
|
|
2208
|
+
"""
|
|
2209
|
+
return pulumi.get(self, "max_vcpu")
|
|
2210
|
+
|
|
2211
|
+
@max_vcpu.setter
|
|
2212
|
+
def max_vcpu(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
2213
|
+
pulumi.set(self, "max_vcpu", value)
|
|
2214
|
+
|
|
2215
|
+
@_builtins.property
|
|
2216
|
+
@pulumi.getter(name="minMemoryGib")
|
|
2217
|
+
def min_memory_gib(self) -> Optional[pulumi.Input[_builtins.float]]:
|
|
2218
|
+
"""
|
|
2219
|
+
Minimum amount of Memory (GiB).
|
|
2220
|
+
"""
|
|
2221
|
+
return pulumi.get(self, "min_memory_gib")
|
|
2222
|
+
|
|
2223
|
+
@min_memory_gib.setter
|
|
2224
|
+
def min_memory_gib(self, value: Optional[pulumi.Input[_builtins.float]]):
|
|
2225
|
+
pulumi.set(self, "min_memory_gib", value)
|
|
2226
|
+
|
|
2227
|
+
@_builtins.property
|
|
2228
|
+
@pulumi.getter(name="minVcpu")
|
|
2229
|
+
def min_vcpu(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
2230
|
+
"""
|
|
2231
|
+
Minimum number of vcpus available.
|
|
2232
|
+
"""
|
|
2233
|
+
return pulumi.get(self, "min_vcpu")
|
|
2234
|
+
|
|
2235
|
+
@min_vcpu.setter
|
|
2236
|
+
def min_vcpu(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
2237
|
+
pulumi.set(self, "min_vcpu", value)
|
|
2238
|
+
|
|
2239
|
+
|
|
2240
|
+
if not MYPY:
|
|
2241
|
+
class OceanImportScheduledTaskArgsDict(TypedDict):
|
|
2242
|
+
shutdown_hours: NotRequired[pulumi.Input['OceanImportScheduledTaskShutdownHoursArgsDict']]
|
|
2243
|
+
"""
|
|
2244
|
+
Set shutdown hours for cluster object.
|
|
2245
|
+
"""
|
|
2246
|
+
tasks: NotRequired[pulumi.Input[Sequence[pulumi.Input['OceanImportScheduledTaskTaskArgsDict']]]]
|
|
2247
|
+
"""
|
|
2248
|
+
The scheduling tasks for the cluster.
|
|
2249
|
+
"""
|
|
2250
|
+
elif False:
|
|
2251
|
+
OceanImportScheduledTaskArgsDict: TypeAlias = Mapping[str, Any]
|
|
2252
|
+
|
|
2253
|
+
@pulumi.input_type
|
|
2254
|
+
class OceanImportScheduledTaskArgs:
|
|
2255
|
+
def __init__(__self__, *,
|
|
2256
|
+
shutdown_hours: Optional[pulumi.Input['OceanImportScheduledTaskShutdownHoursArgs']] = None,
|
|
2257
|
+
tasks: Optional[pulumi.Input[Sequence[pulumi.Input['OceanImportScheduledTaskTaskArgs']]]] = None):
|
|
2258
|
+
"""
|
|
2259
|
+
:param pulumi.Input['OceanImportScheduledTaskShutdownHoursArgs'] shutdown_hours: Set shutdown hours for cluster object.
|
|
2260
|
+
:param pulumi.Input[Sequence[pulumi.Input['OceanImportScheduledTaskTaskArgs']]] tasks: The scheduling tasks for the cluster.
|
|
2261
|
+
"""
|
|
2262
|
+
if shutdown_hours is not None:
|
|
2263
|
+
pulumi.set(__self__, "shutdown_hours", shutdown_hours)
|
|
2264
|
+
if tasks is not None:
|
|
2265
|
+
pulumi.set(__self__, "tasks", tasks)
|
|
2266
|
+
|
|
2267
|
+
@_builtins.property
|
|
2268
|
+
@pulumi.getter(name="shutdownHours")
|
|
2269
|
+
def shutdown_hours(self) -> Optional[pulumi.Input['OceanImportScheduledTaskShutdownHoursArgs']]:
|
|
2270
|
+
"""
|
|
2271
|
+
Set shutdown hours for cluster object.
|
|
2272
|
+
"""
|
|
2273
|
+
return pulumi.get(self, "shutdown_hours")
|
|
2274
|
+
|
|
2275
|
+
@shutdown_hours.setter
|
|
2276
|
+
def shutdown_hours(self, value: Optional[pulumi.Input['OceanImportScheduledTaskShutdownHoursArgs']]):
|
|
2277
|
+
pulumi.set(self, "shutdown_hours", value)
|
|
2278
|
+
|
|
2279
|
+
@_builtins.property
|
|
2280
|
+
@pulumi.getter
|
|
2281
|
+
def tasks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanImportScheduledTaskTaskArgs']]]]:
|
|
2282
|
+
"""
|
|
2283
|
+
The scheduling tasks for the cluster.
|
|
2284
|
+
"""
|
|
2285
|
+
return pulumi.get(self, "tasks")
|
|
2286
|
+
|
|
2287
|
+
@tasks.setter
|
|
2288
|
+
def tasks(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanImportScheduledTaskTaskArgs']]]]):
|
|
2289
|
+
pulumi.set(self, "tasks", value)
|
|
2290
|
+
|
|
2291
|
+
|
|
2292
|
+
if not MYPY:
|
|
2293
|
+
class OceanImportScheduledTaskShutdownHoursArgsDict(TypedDict):
|
|
2294
|
+
time_windows: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]
|
|
2295
|
+
"""
|
|
2296
|
+
Set time windows for shutdown hours. specify a list of 'timeWindows' with at least one time window Each string is in the format of - ddd:hh:mm-ddd:hh:mm ddd = day of week = Sun | Mon | Tue | Wed | Thu | Fri | Sat hh = hour 24 = 0 -23 mm = minute = 0 - 59. Time windows should not overlap. required on cluster.scheduling.isEnabled = `true`. API Times are in UTC
|
|
2297
|
+
Example: Fri:15:30-Wed:14:30
|
|
2298
|
+
"""
|
|
2299
|
+
is_enabled: NotRequired[pulumi.Input[_builtins.bool]]
|
|
2300
|
+
"""
|
|
2301
|
+
Flag to enable / disable the shutdown hours.
|
|
2302
|
+
Example: `true`
|
|
2303
|
+
"""
|
|
2304
|
+
elif False:
|
|
2305
|
+
OceanImportScheduledTaskShutdownHoursArgsDict: TypeAlias = Mapping[str, Any]
|
|
2306
|
+
|
|
2307
|
+
@pulumi.input_type
|
|
2308
|
+
class OceanImportScheduledTaskShutdownHoursArgs:
|
|
2309
|
+
def __init__(__self__, *,
|
|
2310
|
+
time_windows: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]],
|
|
2311
|
+
is_enabled: Optional[pulumi.Input[_builtins.bool]] = None):
|
|
2312
|
+
"""
|
|
2313
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] time_windows: Set time windows for shutdown hours. specify a list of 'timeWindows' with at least one time window Each string is in the format of - ddd:hh:mm-ddd:hh:mm ddd = day of week = Sun | Mon | Tue | Wed | Thu | Fri | Sat hh = hour 24 = 0 -23 mm = minute = 0 - 59. Time windows should not overlap. required on cluster.scheduling.isEnabled = `true`. API Times are in UTC
|
|
2314
|
+
Example: Fri:15:30-Wed:14:30
|
|
2315
|
+
:param pulumi.Input[_builtins.bool] is_enabled: Flag to enable / disable the shutdown hours.
|
|
2316
|
+
Example: `true`
|
|
2317
|
+
"""
|
|
2318
|
+
pulumi.set(__self__, "time_windows", time_windows)
|
|
2319
|
+
if is_enabled is not None:
|
|
2320
|
+
pulumi.set(__self__, "is_enabled", is_enabled)
|
|
2321
|
+
|
|
2322
|
+
@_builtins.property
|
|
2323
|
+
@pulumi.getter(name="timeWindows")
|
|
2324
|
+
def time_windows(self) -> pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]:
|
|
2325
|
+
"""
|
|
2326
|
+
Set time windows for shutdown hours. specify a list of 'timeWindows' with at least one time window Each string is in the format of - ddd:hh:mm-ddd:hh:mm ddd = day of week = Sun | Mon | Tue | Wed | Thu | Fri | Sat hh = hour 24 = 0 -23 mm = minute = 0 - 59. Time windows should not overlap. required on cluster.scheduling.isEnabled = `true`. API Times are in UTC
|
|
2327
|
+
Example: Fri:15:30-Wed:14:30
|
|
2328
|
+
"""
|
|
2329
|
+
return pulumi.get(self, "time_windows")
|
|
2330
|
+
|
|
2331
|
+
@time_windows.setter
|
|
2332
|
+
def time_windows(self, value: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]):
|
|
2333
|
+
pulumi.set(self, "time_windows", value)
|
|
2334
|
+
|
|
2335
|
+
@_builtins.property
|
|
2336
|
+
@pulumi.getter(name="isEnabled")
|
|
2337
|
+
def is_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
2338
|
+
"""
|
|
2339
|
+
Flag to enable / disable the shutdown hours.
|
|
2340
|
+
Example: `true`
|
|
2341
|
+
"""
|
|
2342
|
+
return pulumi.get(self, "is_enabled")
|
|
2343
|
+
|
|
2344
|
+
@is_enabled.setter
|
|
2345
|
+
def is_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1562
2346
|
pulumi.set(self, "is_enabled", value)
|
|
1563
2347
|
|
|
1564
2348
|
|
|
2349
|
+
if not MYPY:
|
|
2350
|
+
class OceanImportScheduledTaskTaskArgsDict(TypedDict):
|
|
2351
|
+
cron_expression: pulumi.Input[_builtins.str]
|
|
2352
|
+
"""
|
|
2353
|
+
A valid cron expression. For example : " * * * * * ".The cron is running in UTC time zone and is in Unix cron format Cron Expression Validator Script. Only one of ‘frequency’ or ‘cronExpression’ should be used at a time. Required for cluster.scheduling.tasks object
|
|
2354
|
+
Example: 0 1 * * *
|
|
2355
|
+
"""
|
|
2356
|
+
is_enabled: pulumi.Input[_builtins.bool]
|
|
2357
|
+
"""
|
|
2358
|
+
Describes whether the task is enabled. When true the task should run when false it should not run. Required for cluster.scheduling.tasks object.
|
|
2359
|
+
"""
|
|
2360
|
+
task_type: pulumi.Input[_builtins.str]
|
|
2361
|
+
"""
|
|
2362
|
+
Valid values: "clusterRoll". Required for cluster.scheduling.tasks object.
|
|
2363
|
+
"""
|
|
2364
|
+
task_parameters: NotRequired[pulumi.Input['OceanImportScheduledTaskTaskTaskParametersArgsDict']]
|
|
2365
|
+
"""
|
|
2366
|
+
The scheduling parameters for the cluster.
|
|
2367
|
+
"""
|
|
2368
|
+
elif False:
|
|
2369
|
+
OceanImportScheduledTaskTaskArgsDict: TypeAlias = Mapping[str, Any]
|
|
2370
|
+
|
|
1565
2371
|
@pulumi.input_type
|
|
1566
2372
|
class OceanImportScheduledTaskTaskArgs:
|
|
1567
2373
|
def __init__(__self__, *,
|
|
1568
|
-
cron_expression: pulumi.Input[str],
|
|
1569
|
-
is_enabled: pulumi.Input[bool],
|
|
1570
|
-
task_type: pulumi.Input[str],
|
|
2374
|
+
cron_expression: pulumi.Input[_builtins.str],
|
|
2375
|
+
is_enabled: pulumi.Input[_builtins.bool],
|
|
2376
|
+
task_type: pulumi.Input[_builtins.str],
|
|
1571
2377
|
task_parameters: Optional[pulumi.Input['OceanImportScheduledTaskTaskTaskParametersArgs']] = None):
|
|
1572
2378
|
"""
|
|
1573
|
-
:param pulumi.Input[str] cron_expression: A valid cron expression. For example : " * * * * * ".The cron is running in UTC time zone and is in Unix cron format Cron Expression Validator Script. Only one of ‘frequency’ or ‘cronExpression’ should be used at a time. Required for cluster.scheduling.tasks object
|
|
2379
|
+
:param pulumi.Input[_builtins.str] cron_expression: A valid cron expression. For example : " * * * * * ".The cron is running in UTC time zone and is in Unix cron format Cron Expression Validator Script. Only one of ‘frequency’ or ‘cronExpression’ should be used at a time. Required for cluster.scheduling.tasks object
|
|
1574
2380
|
Example: 0 1 * * *
|
|
1575
|
-
:param pulumi.Input[bool] is_enabled: Describes whether the task is enabled. When true the task should run when false it should not run. Required for cluster.scheduling.tasks object.
|
|
1576
|
-
:param pulumi.Input[str] task_type: Valid values: "clusterRoll". Required for cluster.scheduling.tasks object.
|
|
2381
|
+
:param pulumi.Input[_builtins.bool] is_enabled: Describes whether the task is enabled. When true the task should run when false it should not run. Required for cluster.scheduling.tasks object.
|
|
2382
|
+
:param pulumi.Input[_builtins.str] task_type: Valid values: "clusterRoll". Required for cluster.scheduling.tasks object.
|
|
1577
2383
|
:param pulumi.Input['OceanImportScheduledTaskTaskTaskParametersArgs'] task_parameters: The scheduling parameters for the cluster.
|
|
1578
2384
|
"""
|
|
1579
2385
|
pulumi.set(__self__, "cron_expression", cron_expression)
|
|
@@ -1582,9 +2388,9 @@ class OceanImportScheduledTaskTaskArgs:
|
|
|
1582
2388
|
if task_parameters is not None:
|
|
1583
2389
|
pulumi.set(__self__, "task_parameters", task_parameters)
|
|
1584
2390
|
|
|
1585
|
-
@property
|
|
2391
|
+
@_builtins.property
|
|
1586
2392
|
@pulumi.getter(name="cronExpression")
|
|
1587
|
-
def cron_expression(self) -> pulumi.Input[str]:
|
|
2393
|
+
def cron_expression(self) -> pulumi.Input[_builtins.str]:
|
|
1588
2394
|
"""
|
|
1589
2395
|
A valid cron expression. For example : " * * * * * ".The cron is running in UTC time zone and is in Unix cron format Cron Expression Validator Script. Only one of ‘frequency’ or ‘cronExpression’ should be used at a time. Required for cluster.scheduling.tasks object
|
|
1590
2396
|
Example: 0 1 * * *
|
|
@@ -1592,34 +2398,34 @@ class OceanImportScheduledTaskTaskArgs:
|
|
|
1592
2398
|
return pulumi.get(self, "cron_expression")
|
|
1593
2399
|
|
|
1594
2400
|
@cron_expression.setter
|
|
1595
|
-
def cron_expression(self, value: pulumi.Input[str]):
|
|
2401
|
+
def cron_expression(self, value: pulumi.Input[_builtins.str]):
|
|
1596
2402
|
pulumi.set(self, "cron_expression", value)
|
|
1597
2403
|
|
|
1598
|
-
@property
|
|
2404
|
+
@_builtins.property
|
|
1599
2405
|
@pulumi.getter(name="isEnabled")
|
|
1600
|
-
def is_enabled(self) -> pulumi.Input[bool]:
|
|
2406
|
+
def is_enabled(self) -> pulumi.Input[_builtins.bool]:
|
|
1601
2407
|
"""
|
|
1602
2408
|
Describes whether the task is enabled. When true the task should run when false it should not run. Required for cluster.scheduling.tasks object.
|
|
1603
2409
|
"""
|
|
1604
2410
|
return pulumi.get(self, "is_enabled")
|
|
1605
2411
|
|
|
1606
2412
|
@is_enabled.setter
|
|
1607
|
-
def is_enabled(self, value: pulumi.Input[bool]):
|
|
2413
|
+
def is_enabled(self, value: pulumi.Input[_builtins.bool]):
|
|
1608
2414
|
pulumi.set(self, "is_enabled", value)
|
|
1609
2415
|
|
|
1610
|
-
@property
|
|
2416
|
+
@_builtins.property
|
|
1611
2417
|
@pulumi.getter(name="taskType")
|
|
1612
|
-
def task_type(self) -> pulumi.Input[str]:
|
|
2418
|
+
def task_type(self) -> pulumi.Input[_builtins.str]:
|
|
1613
2419
|
"""
|
|
1614
2420
|
Valid values: "clusterRoll". Required for cluster.scheduling.tasks object.
|
|
1615
2421
|
"""
|
|
1616
2422
|
return pulumi.get(self, "task_type")
|
|
1617
2423
|
|
|
1618
2424
|
@task_type.setter
|
|
1619
|
-
def task_type(self, value: pulumi.Input[str]):
|
|
2425
|
+
def task_type(self, value: pulumi.Input[_builtins.str]):
|
|
1620
2426
|
pulumi.set(self, "task_type", value)
|
|
1621
2427
|
|
|
1622
|
-
@property
|
|
2428
|
+
@_builtins.property
|
|
1623
2429
|
@pulumi.getter(name="taskParameters")
|
|
1624
2430
|
def task_parameters(self) -> Optional[pulumi.Input['OceanImportScheduledTaskTaskTaskParametersArgs']]:
|
|
1625
2431
|
"""
|
|
@@ -1632,6 +2438,15 @@ class OceanImportScheduledTaskTaskArgs:
|
|
|
1632
2438
|
pulumi.set(self, "task_parameters", value)
|
|
1633
2439
|
|
|
1634
2440
|
|
|
2441
|
+
if not MYPY:
|
|
2442
|
+
class OceanImportScheduledTaskTaskTaskParametersArgsDict(TypedDict):
|
|
2443
|
+
cluster_roll: NotRequired[pulumi.Input['OceanImportScheduledTaskTaskTaskParametersClusterRollArgsDict']]
|
|
2444
|
+
"""
|
|
2445
|
+
The cluster roll parameters for the cluster.
|
|
2446
|
+
"""
|
|
2447
|
+
elif False:
|
|
2448
|
+
OceanImportScheduledTaskTaskTaskParametersArgsDict: TypeAlias = Mapping[str, Any]
|
|
2449
|
+
|
|
1635
2450
|
@pulumi.input_type
|
|
1636
2451
|
class OceanImportScheduledTaskTaskTaskParametersArgs:
|
|
1637
2452
|
def __init__(__self__, *,
|
|
@@ -1642,7 +2457,7 @@ class OceanImportScheduledTaskTaskTaskParametersArgs:
|
|
|
1642
2457
|
if cluster_roll is not None:
|
|
1643
2458
|
pulumi.set(__self__, "cluster_roll", cluster_roll)
|
|
1644
2459
|
|
|
1645
|
-
@property
|
|
2460
|
+
@_builtins.property
|
|
1646
2461
|
@pulumi.getter(name="clusterRoll")
|
|
1647
2462
|
def cluster_roll(self) -> Optional[pulumi.Input['OceanImportScheduledTaskTaskTaskParametersClusterRollArgs']]:
|
|
1648
2463
|
"""
|
|
@@ -1655,18 +2470,39 @@ class OceanImportScheduledTaskTaskTaskParametersArgs:
|
|
|
1655
2470
|
pulumi.set(self, "cluster_roll", value)
|
|
1656
2471
|
|
|
1657
2472
|
|
|
2473
|
+
if not MYPY:
|
|
2474
|
+
class OceanImportScheduledTaskTaskTaskParametersClusterRollArgsDict(TypedDict):
|
|
2475
|
+
batch_min_healthy_percentage: NotRequired[pulumi.Input[_builtins.int]]
|
|
2476
|
+
"""
|
|
2477
|
+
Indicates the threshold of minimum healthy instances in single batch. If the amount of healthy instances in single batch is under the threshold, the cluster 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.
|
|
2478
|
+
"""
|
|
2479
|
+
batch_size_percentage: NotRequired[pulumi.Input[_builtins.int]]
|
|
2480
|
+
"""
|
|
2481
|
+
Value as a percent to set the size of a batch in a roll. Valid values are 0-100.
|
|
2482
|
+
"""
|
|
2483
|
+
comment: NotRequired[pulumi.Input[_builtins.str]]
|
|
2484
|
+
"""
|
|
2485
|
+
Add a comment description for the roll. The comment is limited to 256 chars.
|
|
2486
|
+
"""
|
|
2487
|
+
respect_pdb: NotRequired[pulumi.Input[_builtins.bool]]
|
|
2488
|
+
"""
|
|
2489
|
+
During the roll, if the parameter is set to true we honor PDB during the instance replacement.
|
|
2490
|
+
"""
|
|
2491
|
+
elif False:
|
|
2492
|
+
OceanImportScheduledTaskTaskTaskParametersClusterRollArgsDict: TypeAlias = Mapping[str, Any]
|
|
2493
|
+
|
|
1658
2494
|
@pulumi.input_type
|
|
1659
2495
|
class OceanImportScheduledTaskTaskTaskParametersClusterRollArgs:
|
|
1660
2496
|
def __init__(__self__, *,
|
|
1661
|
-
batch_min_healthy_percentage: Optional[pulumi.Input[int]] = None,
|
|
1662
|
-
batch_size_percentage: Optional[pulumi.Input[int]] = None,
|
|
1663
|
-
comment: Optional[pulumi.Input[str]] = None,
|
|
1664
|
-
respect_pdb: Optional[pulumi.Input[bool]] = None):
|
|
2497
|
+
batch_min_healthy_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2498
|
+
batch_size_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2499
|
+
comment: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2500
|
+
respect_pdb: Optional[pulumi.Input[_builtins.bool]] = None):
|
|
1665
2501
|
"""
|
|
1666
|
-
:param pulumi.Input[int] batch_min_healthy_percentage: Indicates the threshold of minimum healthy instances in single batch. If the amount of healthy instances in single batch is under the threshold, the cluster 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.
|
|
1667
|
-
: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.
|
|
1668
|
-
:param pulumi.Input[str] comment: Add a comment description for the roll. The comment is limited to 256 chars.
|
|
1669
|
-
:param pulumi.Input[bool] respect_pdb: During the roll, if the parameter is set to true we honor PDB during the instance replacement.
|
|
2502
|
+
:param pulumi.Input[_builtins.int] batch_min_healthy_percentage: Indicates the threshold of minimum healthy instances in single batch. If the amount of healthy instances in single batch is under the threshold, the cluster 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.
|
|
2503
|
+
: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.
|
|
2504
|
+
:param pulumi.Input[_builtins.str] comment: Add a comment description for the roll. The comment is limited to 256 chars.
|
|
2505
|
+
:param pulumi.Input[_builtins.bool] respect_pdb: During the roll, if the parameter is set to true we honor PDB during the instance replacement.
|
|
1670
2506
|
"""
|
|
1671
2507
|
if batch_min_healthy_percentage is not None:
|
|
1672
2508
|
pulumi.set(__self__, "batch_min_healthy_percentage", batch_min_healthy_percentage)
|
|
@@ -1677,104 +2513,146 @@ class OceanImportScheduledTaskTaskTaskParametersClusterRollArgs:
|
|
|
1677
2513
|
if respect_pdb is not None:
|
|
1678
2514
|
pulumi.set(__self__, "respect_pdb", respect_pdb)
|
|
1679
2515
|
|
|
1680
|
-
@property
|
|
2516
|
+
@_builtins.property
|
|
1681
2517
|
@pulumi.getter(name="batchMinHealthyPercentage")
|
|
1682
|
-
def batch_min_healthy_percentage(self) -> Optional[pulumi.Input[int]]:
|
|
2518
|
+
def batch_min_healthy_percentage(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1683
2519
|
"""
|
|
1684
2520
|
Indicates the threshold of minimum healthy instances in single batch. If the amount of healthy instances in single batch is under the threshold, the cluster 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.
|
|
1685
2521
|
"""
|
|
1686
2522
|
return pulumi.get(self, "batch_min_healthy_percentage")
|
|
1687
2523
|
|
|
1688
2524
|
@batch_min_healthy_percentage.setter
|
|
1689
|
-
def batch_min_healthy_percentage(self, value: Optional[pulumi.Input[int]]):
|
|
2525
|
+
def batch_min_healthy_percentage(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1690
2526
|
pulumi.set(self, "batch_min_healthy_percentage", value)
|
|
1691
2527
|
|
|
1692
|
-
@property
|
|
2528
|
+
@_builtins.property
|
|
1693
2529
|
@pulumi.getter(name="batchSizePercentage")
|
|
1694
|
-
def batch_size_percentage(self) -> Optional[pulumi.Input[int]]:
|
|
2530
|
+
def batch_size_percentage(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1695
2531
|
"""
|
|
1696
2532
|
Value as a percent to set the size of a batch in a roll. Valid values are 0-100.
|
|
1697
2533
|
"""
|
|
1698
2534
|
return pulumi.get(self, "batch_size_percentage")
|
|
1699
2535
|
|
|
1700
2536
|
@batch_size_percentage.setter
|
|
1701
|
-
def batch_size_percentage(self, value: Optional[pulumi.Input[int]]):
|
|
2537
|
+
def batch_size_percentage(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1702
2538
|
pulumi.set(self, "batch_size_percentage", value)
|
|
1703
2539
|
|
|
1704
|
-
@property
|
|
2540
|
+
@_builtins.property
|
|
1705
2541
|
@pulumi.getter
|
|
1706
|
-
def comment(self) -> Optional[pulumi.Input[str]]:
|
|
2542
|
+
def comment(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1707
2543
|
"""
|
|
1708
2544
|
Add a comment description for the roll. The comment is limited to 256 chars.
|
|
1709
2545
|
"""
|
|
1710
2546
|
return pulumi.get(self, "comment")
|
|
1711
2547
|
|
|
1712
2548
|
@comment.setter
|
|
1713
|
-
def comment(self, value: Optional[pulumi.Input[str]]):
|
|
2549
|
+
def comment(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1714
2550
|
pulumi.set(self, "comment", value)
|
|
1715
2551
|
|
|
1716
|
-
@property
|
|
2552
|
+
@_builtins.property
|
|
1717
2553
|
@pulumi.getter(name="respectPdb")
|
|
1718
|
-
def respect_pdb(self) -> Optional[pulumi.Input[bool]]:
|
|
2554
|
+
def respect_pdb(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1719
2555
|
"""
|
|
1720
2556
|
During the roll, if the parameter is set to true we honor PDB during the instance replacement.
|
|
1721
2557
|
"""
|
|
1722
2558
|
return pulumi.get(self, "respect_pdb")
|
|
1723
2559
|
|
|
1724
2560
|
@respect_pdb.setter
|
|
1725
|
-
def respect_pdb(self, value: Optional[pulumi.Input[bool]]):
|
|
2561
|
+
def respect_pdb(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1726
2562
|
pulumi.set(self, "respect_pdb", value)
|
|
1727
2563
|
|
|
1728
2564
|
|
|
2565
|
+
if not MYPY:
|
|
2566
|
+
class OceanImportShieldedInstanceConfigArgsDict(TypedDict):
|
|
2567
|
+
enable_integrity_monitoring: NotRequired[pulumi.Input[_builtins.bool]]
|
|
2568
|
+
"""
|
|
2569
|
+
Boolean. Enable the integrity monitoring parameter on the GCP instances.
|
|
2570
|
+
"""
|
|
2571
|
+
enable_secure_boot: NotRequired[pulumi.Input[_builtins.bool]]
|
|
2572
|
+
"""
|
|
2573
|
+
Boolean. Enable the secure boot parameter on the GCP instances.
|
|
2574
|
+
"""
|
|
2575
|
+
elif False:
|
|
2576
|
+
OceanImportShieldedInstanceConfigArgsDict: TypeAlias = Mapping[str, Any]
|
|
2577
|
+
|
|
1729
2578
|
@pulumi.input_type
|
|
1730
2579
|
class OceanImportShieldedInstanceConfigArgs:
|
|
1731
2580
|
def __init__(__self__, *,
|
|
1732
|
-
enable_integrity_monitoring: Optional[pulumi.Input[bool]] = None,
|
|
1733
|
-
enable_secure_boot: Optional[pulumi.Input[bool]] = None):
|
|
2581
|
+
enable_integrity_monitoring: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
2582
|
+
enable_secure_boot: Optional[pulumi.Input[_builtins.bool]] = None):
|
|
1734
2583
|
"""
|
|
1735
|
-
:param pulumi.Input[bool] enable_integrity_monitoring: Boolean. Enable the integrity monitoring parameter on the GCP instances.
|
|
1736
|
-
:param pulumi.Input[bool] enable_secure_boot: Boolean. Enable the secure boot parameter on the GCP instances.
|
|
2584
|
+
:param pulumi.Input[_builtins.bool] enable_integrity_monitoring: Boolean. Enable the integrity monitoring parameter on the GCP instances.
|
|
2585
|
+
:param pulumi.Input[_builtins.bool] enable_secure_boot: Boolean. Enable the secure boot parameter on the GCP instances.
|
|
1737
2586
|
"""
|
|
1738
2587
|
if enable_integrity_monitoring is not None:
|
|
1739
2588
|
pulumi.set(__self__, "enable_integrity_monitoring", enable_integrity_monitoring)
|
|
1740
2589
|
if enable_secure_boot is not None:
|
|
1741
2590
|
pulumi.set(__self__, "enable_secure_boot", enable_secure_boot)
|
|
1742
2591
|
|
|
1743
|
-
@property
|
|
2592
|
+
@_builtins.property
|
|
1744
2593
|
@pulumi.getter(name="enableIntegrityMonitoring")
|
|
1745
|
-
def enable_integrity_monitoring(self) -> Optional[pulumi.Input[bool]]:
|
|
2594
|
+
def enable_integrity_monitoring(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1746
2595
|
"""
|
|
1747
2596
|
Boolean. Enable the integrity monitoring parameter on the GCP instances.
|
|
1748
2597
|
"""
|
|
1749
2598
|
return pulumi.get(self, "enable_integrity_monitoring")
|
|
1750
2599
|
|
|
1751
2600
|
@enable_integrity_monitoring.setter
|
|
1752
|
-
def enable_integrity_monitoring(self, value: Optional[pulumi.Input[bool]]):
|
|
2601
|
+
def enable_integrity_monitoring(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1753
2602
|
pulumi.set(self, "enable_integrity_monitoring", value)
|
|
1754
2603
|
|
|
1755
|
-
@property
|
|
2604
|
+
@_builtins.property
|
|
1756
2605
|
@pulumi.getter(name="enableSecureBoot")
|
|
1757
|
-
def enable_secure_boot(self) -> Optional[pulumi.Input[bool]]:
|
|
2606
|
+
def enable_secure_boot(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1758
2607
|
"""
|
|
1759
2608
|
Boolean. Enable the secure boot parameter on the GCP instances.
|
|
1760
2609
|
"""
|
|
1761
2610
|
return pulumi.get(self, "enable_secure_boot")
|
|
1762
2611
|
|
|
1763
2612
|
@enable_secure_boot.setter
|
|
1764
|
-
def enable_secure_boot(self, value: Optional[pulumi.Input[bool]]):
|
|
2613
|
+
def enable_secure_boot(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1765
2614
|
pulumi.set(self, "enable_secure_boot", value)
|
|
1766
2615
|
|
|
1767
2616
|
|
|
2617
|
+
if not MYPY:
|
|
2618
|
+
class OceanImportStrategyArgsDict(TypedDict):
|
|
2619
|
+
draining_timeout: NotRequired[pulumi.Input[_builtins.int]]
|
|
2620
|
+
"""
|
|
2621
|
+
The draining timeout (in seconds) before terminating the instance. If no draining timeout is defined, the default draining timeout will be used.
|
|
2622
|
+
"""
|
|
2623
|
+
preemptible_percentage: NotRequired[pulumi.Input[_builtins.int]]
|
|
2624
|
+
"""
|
|
2625
|
+
Defines the desired preemptible percentage for the cluster.
|
|
2626
|
+
"""
|
|
2627
|
+
provisioning_model: NotRequired[pulumi.Input[_builtins.str]]
|
|
2628
|
+
"""
|
|
2629
|
+
Define the provisioning model of the launched instances. Valid values: `SPOT`, `PREEMPTIBLE`.
|
|
2630
|
+
"""
|
|
2631
|
+
scaling_orientation: NotRequired[pulumi.Input[_builtins.str]]
|
|
2632
|
+
"""
|
|
2633
|
+
Valid Values: `"cost", "availability", "balanced"`. Set this value to control the approach that Ocean takes when launching nodes.
|
|
2634
|
+
"""
|
|
2635
|
+
should_utilize_commitments: NotRequired[pulumi.Input[_builtins.bool]]
|
|
2636
|
+
"""
|
|
2637
|
+
Enable committed use discounts utilization.
|
|
2638
|
+
"""
|
|
2639
|
+
elif False:
|
|
2640
|
+
OceanImportStrategyArgsDict: TypeAlias = Mapping[str, Any]
|
|
2641
|
+
|
|
1768
2642
|
@pulumi.input_type
|
|
1769
2643
|
class OceanImportStrategyArgs:
|
|
1770
2644
|
def __init__(__self__, *,
|
|
1771
|
-
draining_timeout: Optional[pulumi.Input[int]] = None,
|
|
1772
|
-
preemptible_percentage: Optional[pulumi.Input[int]] = None,
|
|
1773
|
-
provisioning_model: Optional[pulumi.Input[str]] = None
|
|
1774
|
-
|
|
1775
|
-
|
|
1776
|
-
|
|
1777
|
-
:param pulumi.Input[
|
|
2645
|
+
draining_timeout: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2646
|
+
preemptible_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2647
|
+
provisioning_model: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2648
|
+
scaling_orientation: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2649
|
+
should_utilize_commitments: Optional[pulumi.Input[_builtins.bool]] = None):
|
|
2650
|
+
"""
|
|
2651
|
+
:param pulumi.Input[_builtins.int] draining_timeout: The draining timeout (in seconds) before terminating the instance. If no draining timeout is defined, the default draining timeout will be used.
|
|
2652
|
+
:param pulumi.Input[_builtins.int] preemptible_percentage: Defines the desired preemptible percentage for the cluster.
|
|
2653
|
+
:param pulumi.Input[_builtins.str] provisioning_model: Define the provisioning model of the launched instances. Valid values: `SPOT`, `PREEMPTIBLE`.
|
|
2654
|
+
:param pulumi.Input[_builtins.str] scaling_orientation: Valid Values: `"cost", "availability", "balanced"`. Set this value to control the approach that Ocean takes when launching nodes.
|
|
2655
|
+
:param pulumi.Input[_builtins.bool] should_utilize_commitments: Enable committed use discounts utilization.
|
|
1778
2656
|
"""
|
|
1779
2657
|
if draining_timeout is not None:
|
|
1780
2658
|
pulumi.set(__self__, "draining_timeout", draining_timeout)
|
|
@@ -1782,53 +2660,98 @@ class OceanImportStrategyArgs:
|
|
|
1782
2660
|
pulumi.set(__self__, "preemptible_percentage", preemptible_percentage)
|
|
1783
2661
|
if provisioning_model is not None:
|
|
1784
2662
|
pulumi.set(__self__, "provisioning_model", provisioning_model)
|
|
2663
|
+
if scaling_orientation is not None:
|
|
2664
|
+
pulumi.set(__self__, "scaling_orientation", scaling_orientation)
|
|
2665
|
+
if should_utilize_commitments is not None:
|
|
2666
|
+
pulumi.set(__self__, "should_utilize_commitments", should_utilize_commitments)
|
|
1785
2667
|
|
|
1786
|
-
@property
|
|
2668
|
+
@_builtins.property
|
|
1787
2669
|
@pulumi.getter(name="drainingTimeout")
|
|
1788
|
-
def draining_timeout(self) -> Optional[pulumi.Input[int]]:
|
|
2670
|
+
def draining_timeout(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1789
2671
|
"""
|
|
1790
2672
|
The draining timeout (in seconds) before terminating the instance. If no draining timeout is defined, the default draining timeout will be used.
|
|
1791
2673
|
"""
|
|
1792
2674
|
return pulumi.get(self, "draining_timeout")
|
|
1793
2675
|
|
|
1794
2676
|
@draining_timeout.setter
|
|
1795
|
-
def draining_timeout(self, value: Optional[pulumi.Input[int]]):
|
|
2677
|
+
def draining_timeout(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1796
2678
|
pulumi.set(self, "draining_timeout", value)
|
|
1797
2679
|
|
|
1798
|
-
@property
|
|
2680
|
+
@_builtins.property
|
|
1799
2681
|
@pulumi.getter(name="preemptiblePercentage")
|
|
1800
|
-
def preemptible_percentage(self) -> Optional[pulumi.Input[int]]:
|
|
2682
|
+
def preemptible_percentage(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1801
2683
|
"""
|
|
1802
2684
|
Defines the desired preemptible percentage for the cluster.
|
|
1803
2685
|
"""
|
|
1804
2686
|
return pulumi.get(self, "preemptible_percentage")
|
|
1805
2687
|
|
|
1806
2688
|
@preemptible_percentage.setter
|
|
1807
|
-
def preemptible_percentage(self, value: Optional[pulumi.Input[int]]):
|
|
2689
|
+
def preemptible_percentage(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1808
2690
|
pulumi.set(self, "preemptible_percentage", value)
|
|
1809
2691
|
|
|
1810
|
-
@property
|
|
2692
|
+
@_builtins.property
|
|
1811
2693
|
@pulumi.getter(name="provisioningModel")
|
|
1812
|
-
def provisioning_model(self) -> Optional[pulumi.Input[str]]:
|
|
2694
|
+
def provisioning_model(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1813
2695
|
"""
|
|
1814
2696
|
Define the provisioning model of the launched instances. Valid values: `SPOT`, `PREEMPTIBLE`.
|
|
1815
2697
|
"""
|
|
1816
2698
|
return pulumi.get(self, "provisioning_model")
|
|
1817
2699
|
|
|
1818
2700
|
@provisioning_model.setter
|
|
1819
|
-
def provisioning_model(self, value: Optional[pulumi.Input[str]]):
|
|
2701
|
+
def provisioning_model(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1820
2702
|
pulumi.set(self, "provisioning_model", value)
|
|
1821
2703
|
|
|
2704
|
+
@_builtins.property
|
|
2705
|
+
@pulumi.getter(name="scalingOrientation")
|
|
2706
|
+
def scaling_orientation(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2707
|
+
"""
|
|
2708
|
+
Valid Values: `"cost", "availability", "balanced"`. Set this value to control the approach that Ocean takes when launching nodes.
|
|
2709
|
+
"""
|
|
2710
|
+
return pulumi.get(self, "scaling_orientation")
|
|
2711
|
+
|
|
2712
|
+
@scaling_orientation.setter
|
|
2713
|
+
def scaling_orientation(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2714
|
+
pulumi.set(self, "scaling_orientation", value)
|
|
2715
|
+
|
|
2716
|
+
@_builtins.property
|
|
2717
|
+
@pulumi.getter(name="shouldUtilizeCommitments")
|
|
2718
|
+
def should_utilize_commitments(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
2719
|
+
"""
|
|
2720
|
+
Enable committed use discounts utilization.
|
|
2721
|
+
"""
|
|
2722
|
+
return pulumi.get(self, "should_utilize_commitments")
|
|
2723
|
+
|
|
2724
|
+
@should_utilize_commitments.setter
|
|
2725
|
+
def should_utilize_commitments(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
2726
|
+
pulumi.set(self, "should_utilize_commitments", value)
|
|
2727
|
+
|
|
2728
|
+
|
|
2729
|
+
if not MYPY:
|
|
2730
|
+
class OceanImportUpdatePolicyArgsDict(TypedDict):
|
|
2731
|
+
should_roll: pulumi.Input[_builtins.bool]
|
|
2732
|
+
"""
|
|
2733
|
+
Enables the roll.
|
|
2734
|
+
"""
|
|
2735
|
+
conditioned_roll: NotRequired[pulumi.Input[_builtins.bool]]
|
|
2736
|
+
"""
|
|
2737
|
+
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 AMI, Key Pair, user data, instance types, load balancers, etc).
|
|
2738
|
+
"""
|
|
2739
|
+
roll_config: NotRequired[pulumi.Input['OceanImportUpdatePolicyRollConfigArgsDict']]
|
|
2740
|
+
"""
|
|
2741
|
+
Holds the roll configuration.
|
|
2742
|
+
"""
|
|
2743
|
+
elif False:
|
|
2744
|
+
OceanImportUpdatePolicyArgsDict: TypeAlias = Mapping[str, Any]
|
|
1822
2745
|
|
|
1823
2746
|
@pulumi.input_type
|
|
1824
2747
|
class OceanImportUpdatePolicyArgs:
|
|
1825
2748
|
def __init__(__self__, *,
|
|
1826
|
-
should_roll: pulumi.Input[bool],
|
|
1827
|
-
conditioned_roll: Optional[pulumi.Input[bool]] = None,
|
|
2749
|
+
should_roll: pulumi.Input[_builtins.bool],
|
|
2750
|
+
conditioned_roll: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1828
2751
|
roll_config: Optional[pulumi.Input['OceanImportUpdatePolicyRollConfigArgs']] = None):
|
|
1829
2752
|
"""
|
|
1830
|
-
:param pulumi.Input[bool] should_roll: Enables the roll.
|
|
1831
|
-
: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 AMI, Key Pair, user data, instance types, load balancers, etc).
|
|
2753
|
+
:param pulumi.Input[_builtins.bool] should_roll: Enables the roll.
|
|
2754
|
+
: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 AMI, Key Pair, user data, instance types, load balancers, etc).
|
|
1832
2755
|
:param pulumi.Input['OceanImportUpdatePolicyRollConfigArgs'] roll_config: Holds the roll configuration.
|
|
1833
2756
|
"""
|
|
1834
2757
|
pulumi.set(__self__, "should_roll", should_roll)
|
|
@@ -1837,31 +2760,31 @@ class OceanImportUpdatePolicyArgs:
|
|
|
1837
2760
|
if roll_config is not None:
|
|
1838
2761
|
pulumi.set(__self__, "roll_config", roll_config)
|
|
1839
2762
|
|
|
1840
|
-
@property
|
|
2763
|
+
@_builtins.property
|
|
1841
2764
|
@pulumi.getter(name="shouldRoll")
|
|
1842
|
-
def should_roll(self) -> pulumi.Input[bool]:
|
|
2765
|
+
def should_roll(self) -> pulumi.Input[_builtins.bool]:
|
|
1843
2766
|
"""
|
|
1844
2767
|
Enables the roll.
|
|
1845
2768
|
"""
|
|
1846
2769
|
return pulumi.get(self, "should_roll")
|
|
1847
2770
|
|
|
1848
2771
|
@should_roll.setter
|
|
1849
|
-
def should_roll(self, value: pulumi.Input[bool]):
|
|
2772
|
+
def should_roll(self, value: pulumi.Input[_builtins.bool]):
|
|
1850
2773
|
pulumi.set(self, "should_roll", value)
|
|
1851
2774
|
|
|
1852
|
-
@property
|
|
2775
|
+
@_builtins.property
|
|
1853
2776
|
@pulumi.getter(name="conditionedRoll")
|
|
1854
|
-
def conditioned_roll(self) -> Optional[pulumi.Input[bool]]:
|
|
2777
|
+
def conditioned_roll(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1855
2778
|
"""
|
|
1856
2779
|
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 AMI, Key Pair, user data, instance types, load balancers, etc).
|
|
1857
2780
|
"""
|
|
1858
2781
|
return pulumi.get(self, "conditioned_roll")
|
|
1859
2782
|
|
|
1860
2783
|
@conditioned_roll.setter
|
|
1861
|
-
def conditioned_roll(self, value: Optional[pulumi.Input[bool]]):
|
|
2784
|
+
def conditioned_roll(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1862
2785
|
pulumi.set(self, "conditioned_roll", value)
|
|
1863
2786
|
|
|
1864
|
-
@property
|
|
2787
|
+
@_builtins.property
|
|
1865
2788
|
@pulumi.getter(name="rollConfig")
|
|
1866
2789
|
def roll_config(self) -> Optional[pulumi.Input['OceanImportUpdatePolicyRollConfigArgs']]:
|
|
1867
2790
|
"""
|
|
@@ -1874,18 +2797,39 @@ class OceanImportUpdatePolicyArgs:
|
|
|
1874
2797
|
pulumi.set(self, "roll_config", value)
|
|
1875
2798
|
|
|
1876
2799
|
|
|
2800
|
+
if not MYPY:
|
|
2801
|
+
class OceanImportUpdatePolicyRollConfigArgsDict(TypedDict):
|
|
2802
|
+
batch_size_percentage: pulumi.Input[_builtins.int]
|
|
2803
|
+
"""
|
|
2804
|
+
Sets the percentage of the instances to deploy in each batch.
|
|
2805
|
+
"""
|
|
2806
|
+
batch_min_healthy_percentage: NotRequired[pulumi.Input[_builtins.int]]
|
|
2807
|
+
"""
|
|
2808
|
+
Default: 50. Indicates the threshold of minimum healthy instances in single batch. If the amount of healthy instances in single batch is under the threshold, the cluster 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.
|
|
2809
|
+
"""
|
|
2810
|
+
launch_spec_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
2811
|
+
"""
|
|
2812
|
+
List of Virtual Node Group identifiers to be rolled.
|
|
2813
|
+
"""
|
|
2814
|
+
respect_pdb: NotRequired[pulumi.Input[_builtins.bool]]
|
|
2815
|
+
"""
|
|
2816
|
+
Default: `false`. During the roll, if the parameter is set to `true` we honor PDB during the instance replacement.
|
|
2817
|
+
"""
|
|
2818
|
+
elif False:
|
|
2819
|
+
OceanImportUpdatePolicyRollConfigArgsDict: TypeAlias = Mapping[str, Any]
|
|
2820
|
+
|
|
1877
2821
|
@pulumi.input_type
|
|
1878
2822
|
class OceanImportUpdatePolicyRollConfigArgs:
|
|
1879
2823
|
def __init__(__self__, *,
|
|
1880
|
-
batch_size_percentage: pulumi.Input[int],
|
|
1881
|
-
batch_min_healthy_percentage: Optional[pulumi.Input[int]] = None,
|
|
1882
|
-
launch_spec_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1883
|
-
respect_pdb: Optional[pulumi.Input[bool]] = None):
|
|
2824
|
+
batch_size_percentage: pulumi.Input[_builtins.int],
|
|
2825
|
+
batch_min_healthy_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2826
|
+
launch_spec_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
2827
|
+
respect_pdb: Optional[pulumi.Input[_builtins.bool]] = None):
|
|
1884
2828
|
"""
|
|
1885
|
-
:param pulumi.Input[int] batch_size_percentage: Sets the percentage of the instances to deploy in each batch.
|
|
1886
|
-
:param pulumi.Input[int] batch_min_healthy_percentage: Default: 50. Indicates the threshold of minimum healthy instances in single batch. If the amount of healthy instances in single batch is under the threshold, the cluster 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.
|
|
1887
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] launch_spec_ids: List of Virtual Node Group identifiers to be rolled.
|
|
1888
|
-
:param pulumi.Input[bool] respect_pdb: Default:
|
|
2829
|
+
:param pulumi.Input[_builtins.int] batch_size_percentage: Sets the percentage of the instances to deploy in each batch.
|
|
2830
|
+
:param pulumi.Input[_builtins.int] batch_min_healthy_percentage: Default: 50. Indicates the threshold of minimum healthy instances in single batch. If the amount of healthy instances in single batch is under the threshold, the cluster 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.
|
|
2831
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] launch_spec_ids: List of Virtual Node Group identifiers to be rolled.
|
|
2832
|
+
:param pulumi.Input[_builtins.bool] respect_pdb: Default: `false`. During the roll, if the parameter is set to `true` we honor PDB during the instance replacement.
|
|
1889
2833
|
"""
|
|
1890
2834
|
pulumi.set(__self__, "batch_size_percentage", batch_size_percentage)
|
|
1891
2835
|
if batch_min_healthy_percentage is not None:
|
|
@@ -1895,67 +2839,88 @@ class OceanImportUpdatePolicyRollConfigArgs:
|
|
|
1895
2839
|
if respect_pdb is not None:
|
|
1896
2840
|
pulumi.set(__self__, "respect_pdb", respect_pdb)
|
|
1897
2841
|
|
|
1898
|
-
@property
|
|
2842
|
+
@_builtins.property
|
|
1899
2843
|
@pulumi.getter(name="batchSizePercentage")
|
|
1900
|
-
def batch_size_percentage(self) -> pulumi.Input[int]:
|
|
2844
|
+
def batch_size_percentage(self) -> pulumi.Input[_builtins.int]:
|
|
1901
2845
|
"""
|
|
1902
2846
|
Sets the percentage of the instances to deploy in each batch.
|
|
1903
2847
|
"""
|
|
1904
2848
|
return pulumi.get(self, "batch_size_percentage")
|
|
1905
2849
|
|
|
1906
2850
|
@batch_size_percentage.setter
|
|
1907
|
-
def batch_size_percentage(self, value: pulumi.Input[int]):
|
|
2851
|
+
def batch_size_percentage(self, value: pulumi.Input[_builtins.int]):
|
|
1908
2852
|
pulumi.set(self, "batch_size_percentage", value)
|
|
1909
2853
|
|
|
1910
|
-
@property
|
|
2854
|
+
@_builtins.property
|
|
1911
2855
|
@pulumi.getter(name="batchMinHealthyPercentage")
|
|
1912
|
-
def batch_min_healthy_percentage(self) -> Optional[pulumi.Input[int]]:
|
|
2856
|
+
def batch_min_healthy_percentage(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1913
2857
|
"""
|
|
1914
2858
|
Default: 50. Indicates the threshold of minimum healthy instances in single batch. If the amount of healthy instances in single batch is under the threshold, the cluster 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.
|
|
1915
2859
|
"""
|
|
1916
2860
|
return pulumi.get(self, "batch_min_healthy_percentage")
|
|
1917
2861
|
|
|
1918
2862
|
@batch_min_healthy_percentage.setter
|
|
1919
|
-
def batch_min_healthy_percentage(self, value: Optional[pulumi.Input[int]]):
|
|
2863
|
+
def batch_min_healthy_percentage(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1920
2864
|
pulumi.set(self, "batch_min_healthy_percentage", value)
|
|
1921
2865
|
|
|
1922
|
-
@property
|
|
2866
|
+
@_builtins.property
|
|
1923
2867
|
@pulumi.getter(name="launchSpecIds")
|
|
1924
|
-
def launch_spec_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
2868
|
+
def launch_spec_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
1925
2869
|
"""
|
|
1926
2870
|
List of Virtual Node Group identifiers to be rolled.
|
|
1927
2871
|
"""
|
|
1928
2872
|
return pulumi.get(self, "launch_spec_ids")
|
|
1929
2873
|
|
|
1930
2874
|
@launch_spec_ids.setter
|
|
1931
|
-
def launch_spec_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
2875
|
+
def launch_spec_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
1932
2876
|
pulumi.set(self, "launch_spec_ids", value)
|
|
1933
2877
|
|
|
1934
|
-
@property
|
|
2878
|
+
@_builtins.property
|
|
1935
2879
|
@pulumi.getter(name="respectPdb")
|
|
1936
|
-
def respect_pdb(self) -> Optional[pulumi.Input[bool]]:
|
|
2880
|
+
def respect_pdb(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1937
2881
|
"""
|
|
1938
|
-
Default:
|
|
2882
|
+
Default: `false`. During the roll, if the parameter is set to `true` we honor PDB during the instance replacement.
|
|
1939
2883
|
"""
|
|
1940
2884
|
return pulumi.get(self, "respect_pdb")
|
|
1941
2885
|
|
|
1942
2886
|
@respect_pdb.setter
|
|
1943
|
-
def respect_pdb(self, value: Optional[pulumi.Input[bool]]):
|
|
2887
|
+
def respect_pdb(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1944
2888
|
pulumi.set(self, "respect_pdb", value)
|
|
1945
2889
|
|
|
1946
2890
|
|
|
2891
|
+
if not MYPY:
|
|
2892
|
+
class OceanLaunchSpecAutoscaleHeadroomArgsDict(TypedDict):
|
|
2893
|
+
num_of_units: pulumi.Input[_builtins.int]
|
|
2894
|
+
"""
|
|
2895
|
+
The number of units to retain as headroom, where each unit has the defined headroom CPU, memory and GPU.
|
|
2896
|
+
"""
|
|
2897
|
+
cpu_per_unit: NotRequired[pulumi.Input[_builtins.int]]
|
|
2898
|
+
"""
|
|
2899
|
+
Optionally configure the number of CPUs to allocate for each headroom unit. CPUs are denoted in millicores, where 1000 millicores = 1 vCPU.
|
|
2900
|
+
"""
|
|
2901
|
+
gpu_per_unit: NotRequired[pulumi.Input[_builtins.int]]
|
|
2902
|
+
"""
|
|
2903
|
+
Optionally configure the number of GPUS to allocate for each headroom unit.
|
|
2904
|
+
"""
|
|
2905
|
+
memory_per_unit: NotRequired[pulumi.Input[_builtins.int]]
|
|
2906
|
+
"""
|
|
2907
|
+
Optionally configure the amount of memory (MiB) to allocate for each headroom unit.
|
|
2908
|
+
"""
|
|
2909
|
+
elif False:
|
|
2910
|
+
OceanLaunchSpecAutoscaleHeadroomArgsDict: TypeAlias = Mapping[str, Any]
|
|
2911
|
+
|
|
1947
2912
|
@pulumi.input_type
|
|
1948
2913
|
class OceanLaunchSpecAutoscaleHeadroomArgs:
|
|
1949
2914
|
def __init__(__self__, *,
|
|
1950
|
-
num_of_units: pulumi.Input[int],
|
|
1951
|
-
cpu_per_unit: Optional[pulumi.Input[int]] = None,
|
|
1952
|
-
gpu_per_unit: Optional[pulumi.Input[int]] = None,
|
|
1953
|
-
memory_per_unit: Optional[pulumi.Input[int]] = None):
|
|
2915
|
+
num_of_units: pulumi.Input[_builtins.int],
|
|
2916
|
+
cpu_per_unit: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2917
|
+
gpu_per_unit: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2918
|
+
memory_per_unit: Optional[pulumi.Input[_builtins.int]] = None):
|
|
1954
2919
|
"""
|
|
1955
|
-
:param pulumi.Input[int] num_of_units: The number of units to retain as headroom, where each unit has the defined headroom CPU, memory and GPU.
|
|
1956
|
-
:param pulumi.Input[int] cpu_per_unit: Optionally configure the number of CPUs to allocate for each headroom unit. CPUs are denoted in millicores, where 1000 millicores = 1 vCPU.
|
|
1957
|
-
:param pulumi.Input[int] gpu_per_unit: Optionally configure the number of GPUS to allocate for each headroom unit.
|
|
1958
|
-
:param pulumi.Input[int] memory_per_unit: Optionally configure the amount of memory (MiB) to allocate for each headroom unit.
|
|
2920
|
+
:param pulumi.Input[_builtins.int] num_of_units: The number of units to retain as headroom, where each unit has the defined headroom CPU, memory and GPU.
|
|
2921
|
+
:param pulumi.Input[_builtins.int] cpu_per_unit: Optionally configure the number of CPUs to allocate for each headroom unit. CPUs are denoted in millicores, where 1000 millicores = 1 vCPU.
|
|
2922
|
+
:param pulumi.Input[_builtins.int] gpu_per_unit: Optionally configure the number of GPUS to allocate for each headroom unit.
|
|
2923
|
+
:param pulumi.Input[_builtins.int] memory_per_unit: Optionally configure the amount of memory (MiB) to allocate for each headroom unit.
|
|
1959
2924
|
"""
|
|
1960
2925
|
pulumi.set(__self__, "num_of_units", num_of_units)
|
|
1961
2926
|
if cpu_per_unit is not None:
|
|
@@ -1965,168 +2930,388 @@ class OceanLaunchSpecAutoscaleHeadroomArgs:
|
|
|
1965
2930
|
if memory_per_unit is not None:
|
|
1966
2931
|
pulumi.set(__self__, "memory_per_unit", memory_per_unit)
|
|
1967
2932
|
|
|
1968
|
-
@property
|
|
2933
|
+
@_builtins.property
|
|
1969
2934
|
@pulumi.getter(name="numOfUnits")
|
|
1970
|
-
def num_of_units(self) -> pulumi.Input[int]:
|
|
2935
|
+
def num_of_units(self) -> pulumi.Input[_builtins.int]:
|
|
1971
2936
|
"""
|
|
1972
2937
|
The number of units to retain as headroom, where each unit has the defined headroom CPU, memory and GPU.
|
|
1973
2938
|
"""
|
|
1974
2939
|
return pulumi.get(self, "num_of_units")
|
|
1975
2940
|
|
|
1976
2941
|
@num_of_units.setter
|
|
1977
|
-
def num_of_units(self, value: pulumi.Input[int]):
|
|
2942
|
+
def num_of_units(self, value: pulumi.Input[_builtins.int]):
|
|
1978
2943
|
pulumi.set(self, "num_of_units", value)
|
|
1979
2944
|
|
|
1980
|
-
@property
|
|
2945
|
+
@_builtins.property
|
|
1981
2946
|
@pulumi.getter(name="cpuPerUnit")
|
|
1982
|
-
def cpu_per_unit(self) -> Optional[pulumi.Input[int]]:
|
|
2947
|
+
def cpu_per_unit(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1983
2948
|
"""
|
|
1984
2949
|
Optionally configure the number of CPUs to allocate for each headroom unit. CPUs are denoted in millicores, where 1000 millicores = 1 vCPU.
|
|
1985
2950
|
"""
|
|
1986
2951
|
return pulumi.get(self, "cpu_per_unit")
|
|
1987
2952
|
|
|
1988
2953
|
@cpu_per_unit.setter
|
|
1989
|
-
def cpu_per_unit(self, value: Optional[pulumi.Input[int]]):
|
|
2954
|
+
def cpu_per_unit(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1990
2955
|
pulumi.set(self, "cpu_per_unit", value)
|
|
1991
2956
|
|
|
1992
|
-
@property
|
|
2957
|
+
@_builtins.property
|
|
1993
2958
|
@pulumi.getter(name="gpuPerUnit")
|
|
1994
|
-
def gpu_per_unit(self) -> Optional[pulumi.Input[int]]:
|
|
2959
|
+
def gpu_per_unit(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1995
2960
|
"""
|
|
1996
2961
|
Optionally configure the number of GPUS to allocate for each headroom unit.
|
|
1997
2962
|
"""
|
|
1998
2963
|
return pulumi.get(self, "gpu_per_unit")
|
|
1999
2964
|
|
|
2000
2965
|
@gpu_per_unit.setter
|
|
2001
|
-
def gpu_per_unit(self, value: Optional[pulumi.Input[int]]):
|
|
2966
|
+
def gpu_per_unit(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
2002
2967
|
pulumi.set(self, "gpu_per_unit", value)
|
|
2003
2968
|
|
|
2004
|
-
@property
|
|
2969
|
+
@_builtins.property
|
|
2005
2970
|
@pulumi.getter(name="memoryPerUnit")
|
|
2006
|
-
def memory_per_unit(self) -> Optional[pulumi.Input[int]]:
|
|
2971
|
+
def memory_per_unit(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
2007
2972
|
"""
|
|
2008
2973
|
Optionally configure the amount of memory (MiB) to allocate for each headroom unit.
|
|
2009
2974
|
"""
|
|
2010
2975
|
return pulumi.get(self, "memory_per_unit")
|
|
2011
2976
|
|
|
2012
2977
|
@memory_per_unit.setter
|
|
2013
|
-
def memory_per_unit(self, value: Optional[pulumi.Input[int]]):
|
|
2978
|
+
def memory_per_unit(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
2014
2979
|
pulumi.set(self, "memory_per_unit", value)
|
|
2015
2980
|
|
|
2016
2981
|
|
|
2982
|
+
if not MYPY:
|
|
2983
|
+
class OceanLaunchSpecAutoscaleHeadroomsAutomaticArgsDict(TypedDict):
|
|
2984
|
+
auto_headroom_percentage: NotRequired[pulumi.Input[_builtins.int]]
|
|
2985
|
+
"""
|
|
2986
|
+
Number between 0-200 to control the headroom % of the specific Virtual Node Group. Effective when cluster.autoScaler.headroom.automatic.`is_enabled` = true is set on the Ocean cluster.
|
|
2987
|
+
"""
|
|
2988
|
+
elif False:
|
|
2989
|
+
OceanLaunchSpecAutoscaleHeadroomsAutomaticArgsDict: TypeAlias = Mapping[str, Any]
|
|
2990
|
+
|
|
2017
2991
|
@pulumi.input_type
|
|
2018
2992
|
class OceanLaunchSpecAutoscaleHeadroomsAutomaticArgs:
|
|
2019
2993
|
def __init__(__self__, *,
|
|
2020
|
-
auto_headroom_percentage: Optional[pulumi.Input[int]] = None):
|
|
2994
|
+
auto_headroom_percentage: Optional[pulumi.Input[_builtins.int]] = None):
|
|
2021
2995
|
"""
|
|
2022
|
-
:param pulumi.Input[int] auto_headroom_percentage: Number between 0-200 to control the headroom % of the specific Virtual Node Group. Effective when cluster.autoScaler.headroom.automatic.`is_enabled` = true is set on the Ocean cluster.
|
|
2996
|
+
:param pulumi.Input[_builtins.int] auto_headroom_percentage: Number between 0-200 to control the headroom % of the specific Virtual Node Group. Effective when cluster.autoScaler.headroom.automatic.`is_enabled` = true is set on the Ocean cluster.
|
|
2023
2997
|
"""
|
|
2024
2998
|
if auto_headroom_percentage is not None:
|
|
2025
2999
|
pulumi.set(__self__, "auto_headroom_percentage", auto_headroom_percentage)
|
|
2026
3000
|
|
|
2027
|
-
@property
|
|
3001
|
+
@_builtins.property
|
|
2028
3002
|
@pulumi.getter(name="autoHeadroomPercentage")
|
|
2029
|
-
def auto_headroom_percentage(self) -> Optional[pulumi.Input[int]]:
|
|
3003
|
+
def auto_headroom_percentage(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
2030
3004
|
"""
|
|
2031
3005
|
Number between 0-200 to control the headroom % of the specific Virtual Node Group. Effective when cluster.autoScaler.headroom.automatic.`is_enabled` = true is set on the Ocean cluster.
|
|
2032
3006
|
"""
|
|
2033
3007
|
return pulumi.get(self, "auto_headroom_percentage")
|
|
2034
3008
|
|
|
2035
3009
|
@auto_headroom_percentage.setter
|
|
2036
|
-
def auto_headroom_percentage(self, value: Optional[pulumi.Input[int]]):
|
|
3010
|
+
def auto_headroom_percentage(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
2037
3011
|
pulumi.set(self, "auto_headroom_percentage", value)
|
|
2038
3012
|
|
|
2039
3013
|
|
|
3014
|
+
if not MYPY:
|
|
3015
|
+
class OceanLaunchSpecCreateOptionsArgsDict(TypedDict):
|
|
3016
|
+
initial_nodes: NotRequired[pulumi.Input[_builtins.int]]
|
|
3017
|
+
"""
|
|
3018
|
+
When set to an integer greater than 0, a corresponding amount of nodes will be launched from the created Virtual Node Group.
|
|
3019
|
+
"""
|
|
3020
|
+
elif False:
|
|
3021
|
+
OceanLaunchSpecCreateOptionsArgsDict: TypeAlias = Mapping[str, Any]
|
|
3022
|
+
|
|
3023
|
+
@pulumi.input_type
|
|
3024
|
+
class OceanLaunchSpecCreateOptionsArgs:
|
|
3025
|
+
def __init__(__self__, *,
|
|
3026
|
+
initial_nodes: Optional[pulumi.Input[_builtins.int]] = None):
|
|
3027
|
+
"""
|
|
3028
|
+
:param pulumi.Input[_builtins.int] initial_nodes: When set to an integer greater than 0, a corresponding amount of nodes will be launched from the created Virtual Node Group.
|
|
3029
|
+
"""
|
|
3030
|
+
if initial_nodes is not None:
|
|
3031
|
+
pulumi.set(__self__, "initial_nodes", initial_nodes)
|
|
3032
|
+
|
|
3033
|
+
@_builtins.property
|
|
3034
|
+
@pulumi.getter(name="initialNodes")
|
|
3035
|
+
def initial_nodes(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
3036
|
+
"""
|
|
3037
|
+
When set to an integer greater than 0, a corresponding amount of nodes will be launched from the created Virtual Node Group.
|
|
3038
|
+
"""
|
|
3039
|
+
return pulumi.get(self, "initial_nodes")
|
|
3040
|
+
|
|
3041
|
+
@initial_nodes.setter
|
|
3042
|
+
def initial_nodes(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
3043
|
+
pulumi.set(self, "initial_nodes", value)
|
|
3044
|
+
|
|
3045
|
+
|
|
3046
|
+
if not MYPY:
|
|
3047
|
+
class OceanLaunchSpecFiltersArgsDict(TypedDict):
|
|
3048
|
+
exclude_families: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
3049
|
+
"""
|
|
3050
|
+
Types belonging to a family from the ExcludeFamilies will not be available for scaling (asterisk wildcard is also supported). For example, C* will exclude instance types from these families: c5, c4, c4a, etc.
|
|
3051
|
+
"""
|
|
3052
|
+
include_families: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
3053
|
+
"""
|
|
3054
|
+
Types belonging to a family from the IncludeFamilies will be available for scaling (asterisk wildcard is also supported). For example, C* will include instance types from these families: c5, c4, c4a, etc.
|
|
3055
|
+
"""
|
|
3056
|
+
max_memory_gib: NotRequired[pulumi.Input[_builtins.float]]
|
|
3057
|
+
"""
|
|
3058
|
+
Maximum amount of Memory (GiB).
|
|
3059
|
+
"""
|
|
3060
|
+
max_vcpu: NotRequired[pulumi.Input[_builtins.int]]
|
|
3061
|
+
"""
|
|
3062
|
+
Maximum number of vcpus available.
|
|
3063
|
+
"""
|
|
3064
|
+
min_memory_gib: NotRequired[pulumi.Input[_builtins.float]]
|
|
3065
|
+
"""
|
|
3066
|
+
Minimum amount of Memory (GiB).
|
|
3067
|
+
"""
|
|
3068
|
+
min_vcpu: NotRequired[pulumi.Input[_builtins.int]]
|
|
3069
|
+
"""
|
|
3070
|
+
Minimum number of vcpus available.
|
|
3071
|
+
"""
|
|
3072
|
+
elif False:
|
|
3073
|
+
OceanLaunchSpecFiltersArgsDict: TypeAlias = Mapping[str, Any]
|
|
3074
|
+
|
|
3075
|
+
@pulumi.input_type
|
|
3076
|
+
class OceanLaunchSpecFiltersArgs:
|
|
3077
|
+
def __init__(__self__, *,
|
|
3078
|
+
exclude_families: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
3079
|
+
include_families: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
3080
|
+
max_memory_gib: Optional[pulumi.Input[_builtins.float]] = None,
|
|
3081
|
+
max_vcpu: Optional[pulumi.Input[_builtins.int]] = None,
|
|
3082
|
+
min_memory_gib: Optional[pulumi.Input[_builtins.float]] = None,
|
|
3083
|
+
min_vcpu: Optional[pulumi.Input[_builtins.int]] = None):
|
|
3084
|
+
"""
|
|
3085
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] exclude_families: Types belonging to a family from the ExcludeFamilies will not be available for scaling (asterisk wildcard is also supported). For example, C* will exclude instance types from these families: c5, c4, c4a, etc.
|
|
3086
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] include_families: Types belonging to a family from the IncludeFamilies will be available for scaling (asterisk wildcard is also supported). For example, C* will include instance types from these families: c5, c4, c4a, etc.
|
|
3087
|
+
:param pulumi.Input[_builtins.float] max_memory_gib: Maximum amount of Memory (GiB).
|
|
3088
|
+
:param pulumi.Input[_builtins.int] max_vcpu: Maximum number of vcpus available.
|
|
3089
|
+
:param pulumi.Input[_builtins.float] min_memory_gib: Minimum amount of Memory (GiB).
|
|
3090
|
+
:param pulumi.Input[_builtins.int] min_vcpu: Minimum number of vcpus available.
|
|
3091
|
+
"""
|
|
3092
|
+
if exclude_families is not None:
|
|
3093
|
+
pulumi.set(__self__, "exclude_families", exclude_families)
|
|
3094
|
+
if include_families is not None:
|
|
3095
|
+
pulumi.set(__self__, "include_families", include_families)
|
|
3096
|
+
if max_memory_gib is not None:
|
|
3097
|
+
pulumi.set(__self__, "max_memory_gib", max_memory_gib)
|
|
3098
|
+
if max_vcpu is not None:
|
|
3099
|
+
pulumi.set(__self__, "max_vcpu", max_vcpu)
|
|
3100
|
+
if min_memory_gib is not None:
|
|
3101
|
+
pulumi.set(__self__, "min_memory_gib", min_memory_gib)
|
|
3102
|
+
if min_vcpu is not None:
|
|
3103
|
+
pulumi.set(__self__, "min_vcpu", min_vcpu)
|
|
3104
|
+
|
|
3105
|
+
@_builtins.property
|
|
3106
|
+
@pulumi.getter(name="excludeFamilies")
|
|
3107
|
+
def exclude_families(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
3108
|
+
"""
|
|
3109
|
+
Types belonging to a family from the ExcludeFamilies will not be available for scaling (asterisk wildcard is also supported). For example, C* will exclude instance types from these families: c5, c4, c4a, etc.
|
|
3110
|
+
"""
|
|
3111
|
+
return pulumi.get(self, "exclude_families")
|
|
3112
|
+
|
|
3113
|
+
@exclude_families.setter
|
|
3114
|
+
def exclude_families(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
3115
|
+
pulumi.set(self, "exclude_families", value)
|
|
3116
|
+
|
|
3117
|
+
@_builtins.property
|
|
3118
|
+
@pulumi.getter(name="includeFamilies")
|
|
3119
|
+
def include_families(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
3120
|
+
"""
|
|
3121
|
+
Types belonging to a family from the IncludeFamilies will be available for scaling (asterisk wildcard is also supported). For example, C* will include instance types from these families: c5, c4, c4a, etc.
|
|
3122
|
+
"""
|
|
3123
|
+
return pulumi.get(self, "include_families")
|
|
3124
|
+
|
|
3125
|
+
@include_families.setter
|
|
3126
|
+
def include_families(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
3127
|
+
pulumi.set(self, "include_families", value)
|
|
3128
|
+
|
|
3129
|
+
@_builtins.property
|
|
3130
|
+
@pulumi.getter(name="maxMemoryGib")
|
|
3131
|
+
def max_memory_gib(self) -> Optional[pulumi.Input[_builtins.float]]:
|
|
3132
|
+
"""
|
|
3133
|
+
Maximum amount of Memory (GiB).
|
|
3134
|
+
"""
|
|
3135
|
+
return pulumi.get(self, "max_memory_gib")
|
|
3136
|
+
|
|
3137
|
+
@max_memory_gib.setter
|
|
3138
|
+
def max_memory_gib(self, value: Optional[pulumi.Input[_builtins.float]]):
|
|
3139
|
+
pulumi.set(self, "max_memory_gib", value)
|
|
3140
|
+
|
|
3141
|
+
@_builtins.property
|
|
3142
|
+
@pulumi.getter(name="maxVcpu")
|
|
3143
|
+
def max_vcpu(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
3144
|
+
"""
|
|
3145
|
+
Maximum number of vcpus available.
|
|
3146
|
+
"""
|
|
3147
|
+
return pulumi.get(self, "max_vcpu")
|
|
3148
|
+
|
|
3149
|
+
@max_vcpu.setter
|
|
3150
|
+
def max_vcpu(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
3151
|
+
pulumi.set(self, "max_vcpu", value)
|
|
3152
|
+
|
|
3153
|
+
@_builtins.property
|
|
3154
|
+
@pulumi.getter(name="minMemoryGib")
|
|
3155
|
+
def min_memory_gib(self) -> Optional[pulumi.Input[_builtins.float]]:
|
|
3156
|
+
"""
|
|
3157
|
+
Minimum amount of Memory (GiB).
|
|
3158
|
+
"""
|
|
3159
|
+
return pulumi.get(self, "min_memory_gib")
|
|
3160
|
+
|
|
3161
|
+
@min_memory_gib.setter
|
|
3162
|
+
def min_memory_gib(self, value: Optional[pulumi.Input[_builtins.float]]):
|
|
3163
|
+
pulumi.set(self, "min_memory_gib", value)
|
|
3164
|
+
|
|
3165
|
+
@_builtins.property
|
|
3166
|
+
@pulumi.getter(name="minVcpu")
|
|
3167
|
+
def min_vcpu(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
3168
|
+
"""
|
|
3169
|
+
Minimum number of vcpus available.
|
|
3170
|
+
"""
|
|
3171
|
+
return pulumi.get(self, "min_vcpu")
|
|
3172
|
+
|
|
3173
|
+
@min_vcpu.setter
|
|
3174
|
+
def min_vcpu(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
3175
|
+
pulumi.set(self, "min_vcpu", value)
|
|
3176
|
+
|
|
3177
|
+
|
|
3178
|
+
if not MYPY:
|
|
3179
|
+
class OceanLaunchSpecLabelArgsDict(TypedDict):
|
|
3180
|
+
key: NotRequired[pulumi.Input[_builtins.str]]
|
|
3181
|
+
"""
|
|
3182
|
+
The label key.
|
|
3183
|
+
"""
|
|
3184
|
+
value: NotRequired[pulumi.Input[_builtins.str]]
|
|
3185
|
+
"""
|
|
3186
|
+
The label value.
|
|
3187
|
+
"""
|
|
3188
|
+
elif False:
|
|
3189
|
+
OceanLaunchSpecLabelArgsDict: TypeAlias = Mapping[str, Any]
|
|
3190
|
+
|
|
2040
3191
|
@pulumi.input_type
|
|
2041
3192
|
class OceanLaunchSpecLabelArgs:
|
|
2042
3193
|
def __init__(__self__, *,
|
|
2043
|
-
key: Optional[pulumi.Input[str]] = None,
|
|
2044
|
-
value: Optional[pulumi.Input[str]] = None):
|
|
3194
|
+
key: Optional[pulumi.Input[_builtins.str]] = None,
|
|
3195
|
+
value: Optional[pulumi.Input[_builtins.str]] = None):
|
|
2045
3196
|
"""
|
|
2046
|
-
:param pulumi.Input[str] key: The label key.
|
|
2047
|
-
:param pulumi.Input[str] value: The label value.
|
|
3197
|
+
:param pulumi.Input[_builtins.str] key: The label key.
|
|
3198
|
+
:param pulumi.Input[_builtins.str] value: The label value.
|
|
2048
3199
|
"""
|
|
2049
3200
|
if key is not None:
|
|
2050
3201
|
pulumi.set(__self__, "key", key)
|
|
2051
3202
|
if value is not None:
|
|
2052
3203
|
pulumi.set(__self__, "value", value)
|
|
2053
3204
|
|
|
2054
|
-
@property
|
|
3205
|
+
@_builtins.property
|
|
2055
3206
|
@pulumi.getter
|
|
2056
|
-
def key(self) -> Optional[pulumi.Input[str]]:
|
|
3207
|
+
def key(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2057
3208
|
"""
|
|
2058
3209
|
The label key.
|
|
2059
3210
|
"""
|
|
2060
3211
|
return pulumi.get(self, "key")
|
|
2061
3212
|
|
|
2062
3213
|
@key.setter
|
|
2063
|
-
def key(self, value: Optional[pulumi.Input[str]]):
|
|
3214
|
+
def key(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2064
3215
|
pulumi.set(self, "key", value)
|
|
2065
3216
|
|
|
2066
|
-
@property
|
|
3217
|
+
@_builtins.property
|
|
2067
3218
|
@pulumi.getter
|
|
2068
|
-
def value(self) -> Optional[pulumi.Input[str]]:
|
|
3219
|
+
def value(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2069
3220
|
"""
|
|
2070
3221
|
The label value.
|
|
2071
3222
|
"""
|
|
2072
3223
|
return pulumi.get(self, "value")
|
|
2073
3224
|
|
|
2074
3225
|
@value.setter
|
|
2075
|
-
def value(self, value: Optional[pulumi.Input[str]]):
|
|
3226
|
+
def value(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2076
3227
|
pulumi.set(self, "value", value)
|
|
2077
3228
|
|
|
2078
3229
|
|
|
3230
|
+
if not MYPY:
|
|
3231
|
+
class OceanLaunchSpecMetadataArgsDict(TypedDict):
|
|
3232
|
+
key: NotRequired[pulumi.Input[_builtins.str]]
|
|
3233
|
+
"""
|
|
3234
|
+
The metadata key.
|
|
3235
|
+
"""
|
|
3236
|
+
value: NotRequired[pulumi.Input[_builtins.str]]
|
|
3237
|
+
"""
|
|
3238
|
+
The metadata value.
|
|
3239
|
+
"""
|
|
3240
|
+
elif False:
|
|
3241
|
+
OceanLaunchSpecMetadataArgsDict: TypeAlias = Mapping[str, Any]
|
|
3242
|
+
|
|
2079
3243
|
@pulumi.input_type
|
|
2080
3244
|
class OceanLaunchSpecMetadataArgs:
|
|
2081
3245
|
def __init__(__self__, *,
|
|
2082
|
-
key: Optional[pulumi.Input[str]] = None,
|
|
2083
|
-
value: Optional[pulumi.Input[str]] = None):
|
|
3246
|
+
key: Optional[pulumi.Input[_builtins.str]] = None,
|
|
3247
|
+
value: Optional[pulumi.Input[_builtins.str]] = None):
|
|
2084
3248
|
"""
|
|
2085
|
-
:param pulumi.Input[str] key: The metadata key.
|
|
2086
|
-
:param pulumi.Input[str] value: The metadata value.
|
|
3249
|
+
:param pulumi.Input[_builtins.str] key: The metadata key.
|
|
3250
|
+
:param pulumi.Input[_builtins.str] value: The metadata value.
|
|
2087
3251
|
"""
|
|
2088
3252
|
if key is not None:
|
|
2089
3253
|
pulumi.set(__self__, "key", key)
|
|
2090
3254
|
if value is not None:
|
|
2091
3255
|
pulumi.set(__self__, "value", value)
|
|
2092
3256
|
|
|
2093
|
-
@property
|
|
3257
|
+
@_builtins.property
|
|
2094
3258
|
@pulumi.getter
|
|
2095
|
-
def key(self) -> Optional[pulumi.Input[str]]:
|
|
3259
|
+
def key(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2096
3260
|
"""
|
|
2097
3261
|
The metadata key.
|
|
2098
3262
|
"""
|
|
2099
3263
|
return pulumi.get(self, "key")
|
|
2100
3264
|
|
|
2101
3265
|
@key.setter
|
|
2102
|
-
def key(self, value: Optional[pulumi.Input[str]]):
|
|
3266
|
+
def key(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2103
3267
|
pulumi.set(self, "key", value)
|
|
2104
3268
|
|
|
2105
|
-
@property
|
|
3269
|
+
@_builtins.property
|
|
2106
3270
|
@pulumi.getter
|
|
2107
|
-
def value(self) -> Optional[pulumi.Input[str]]:
|
|
3271
|
+
def value(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2108
3272
|
"""
|
|
2109
3273
|
The metadata value.
|
|
2110
3274
|
"""
|
|
2111
3275
|
return pulumi.get(self, "value")
|
|
2112
3276
|
|
|
2113
3277
|
@value.setter
|
|
2114
|
-
def value(self, value: Optional[pulumi.Input[str]]):
|
|
3278
|
+
def value(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2115
3279
|
pulumi.set(self, "value", value)
|
|
2116
3280
|
|
|
2117
3281
|
|
|
3282
|
+
if not MYPY:
|
|
3283
|
+
class OceanLaunchSpecNetworkInterfaceArgsDict(TypedDict):
|
|
3284
|
+
network: pulumi.Input[_builtins.str]
|
|
3285
|
+
"""
|
|
3286
|
+
The name of the network.
|
|
3287
|
+
"""
|
|
3288
|
+
access_configs: NotRequired[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecNetworkInterfaceAccessConfigArgsDict']]]]
|
|
3289
|
+
"""
|
|
3290
|
+
The network protocol of the VNG.
|
|
3291
|
+
"""
|
|
3292
|
+
alias_ip_ranges: NotRequired[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecNetworkInterfaceAliasIpRangeArgsDict']]]]
|
|
3293
|
+
"""
|
|
3294
|
+
use the imported node pool’s associated aliasIpRange to assign secondary IP addresses to the nodes. Cannot be changed after VNG creation.
|
|
3295
|
+
"""
|
|
3296
|
+
project_id: NotRequired[pulumi.Input[_builtins.str]]
|
|
3297
|
+
"""
|
|
3298
|
+
Use a network resource from a different project. Set the project identifier to use its network resource. This parameter is relevant only if the network resource is in a different project.
|
|
3299
|
+
"""
|
|
3300
|
+
elif False:
|
|
3301
|
+
OceanLaunchSpecNetworkInterfaceArgsDict: TypeAlias = Mapping[str, Any]
|
|
3302
|
+
|
|
2118
3303
|
@pulumi.input_type
|
|
2119
3304
|
class OceanLaunchSpecNetworkInterfaceArgs:
|
|
2120
3305
|
def __init__(__self__, *,
|
|
2121
|
-
network: pulumi.Input[str],
|
|
3306
|
+
network: pulumi.Input[_builtins.str],
|
|
2122
3307
|
access_configs: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecNetworkInterfaceAccessConfigArgs']]]] = None,
|
|
2123
3308
|
alias_ip_ranges: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecNetworkInterfaceAliasIpRangeArgs']]]] = None,
|
|
2124
|
-
project_id: Optional[pulumi.Input[str]] = None):
|
|
3309
|
+
project_id: Optional[pulumi.Input[_builtins.str]] = None):
|
|
2125
3310
|
"""
|
|
2126
|
-
:param pulumi.Input[str] network: The name of the network.
|
|
3311
|
+
:param pulumi.Input[_builtins.str] network: The name of the network.
|
|
2127
3312
|
:param pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecNetworkInterfaceAccessConfigArgs']]] access_configs: The network protocol of the VNG.
|
|
2128
3313
|
:param pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecNetworkInterfaceAliasIpRangeArgs']]] alias_ip_ranges: use the imported node pool’s associated aliasIpRange to assign secondary IP addresses to the nodes. Cannot be changed after VNG creation.
|
|
2129
|
-
:param pulumi.Input[str] project_id: Use a network resource from a different project. Set the project identifier to use its network resource. This parameter is relevant only if the network resource is in a different project.
|
|
3314
|
+
:param pulumi.Input[_builtins.str] project_id: Use a network resource from a different project. Set the project identifier to use its network resource. This parameter is relevant only if the network resource is in a different project.
|
|
2130
3315
|
"""
|
|
2131
3316
|
pulumi.set(__self__, "network", network)
|
|
2132
3317
|
if access_configs is not None:
|
|
@@ -2136,19 +3321,19 @@ class OceanLaunchSpecNetworkInterfaceArgs:
|
|
|
2136
3321
|
if project_id is not None:
|
|
2137
3322
|
pulumi.set(__self__, "project_id", project_id)
|
|
2138
3323
|
|
|
2139
|
-
@property
|
|
3324
|
+
@_builtins.property
|
|
2140
3325
|
@pulumi.getter
|
|
2141
|
-
def network(self) -> pulumi.Input[str]:
|
|
3326
|
+
def network(self) -> pulumi.Input[_builtins.str]:
|
|
2142
3327
|
"""
|
|
2143
3328
|
The name of the network.
|
|
2144
3329
|
"""
|
|
2145
3330
|
return pulumi.get(self, "network")
|
|
2146
3331
|
|
|
2147
3332
|
@network.setter
|
|
2148
|
-
def network(self, value: pulumi.Input[str]):
|
|
3333
|
+
def network(self, value: pulumi.Input[_builtins.str]):
|
|
2149
3334
|
pulumi.set(self, "network", value)
|
|
2150
3335
|
|
|
2151
|
-
@property
|
|
3336
|
+
@_builtins.property
|
|
2152
3337
|
@pulumi.getter(name="accessConfigs")
|
|
2153
3338
|
def access_configs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecNetworkInterfaceAccessConfigArgs']]]]:
|
|
2154
3339
|
"""
|
|
@@ -2160,7 +3345,7 @@ class OceanLaunchSpecNetworkInterfaceArgs:
|
|
|
2160
3345
|
def access_configs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecNetworkInterfaceAccessConfigArgs']]]]):
|
|
2161
3346
|
pulumi.set(self, "access_configs", value)
|
|
2162
3347
|
|
|
2163
|
-
@property
|
|
3348
|
+
@_builtins.property
|
|
2164
3349
|
@pulumi.getter(name="aliasIpRanges")
|
|
2165
3350
|
def alias_ip_ranges(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecNetworkInterfaceAliasIpRangeArgs']]]]:
|
|
2166
3351
|
"""
|
|
@@ -2172,145 +3357,205 @@ class OceanLaunchSpecNetworkInterfaceArgs:
|
|
|
2172
3357
|
def alias_ip_ranges(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecNetworkInterfaceAliasIpRangeArgs']]]]):
|
|
2173
3358
|
pulumi.set(self, "alias_ip_ranges", value)
|
|
2174
3359
|
|
|
2175
|
-
@property
|
|
3360
|
+
@_builtins.property
|
|
2176
3361
|
@pulumi.getter(name="projectId")
|
|
2177
|
-
def project_id(self) -> Optional[pulumi.Input[str]]:
|
|
3362
|
+
def project_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2178
3363
|
"""
|
|
2179
3364
|
Use a network resource from a different project. Set the project identifier to use its network resource. This parameter is relevant only if the network resource is in a different project.
|
|
2180
3365
|
"""
|
|
2181
3366
|
return pulumi.get(self, "project_id")
|
|
2182
3367
|
|
|
2183
3368
|
@project_id.setter
|
|
2184
|
-
def project_id(self, value: Optional[pulumi.Input[str]]):
|
|
3369
|
+
def project_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2185
3370
|
pulumi.set(self, "project_id", value)
|
|
2186
3371
|
|
|
2187
3372
|
|
|
3373
|
+
if not MYPY:
|
|
3374
|
+
class OceanLaunchSpecNetworkInterfaceAccessConfigArgsDict(TypedDict):
|
|
3375
|
+
name: NotRequired[pulumi.Input[_builtins.str]]
|
|
3376
|
+
"""
|
|
3377
|
+
The name of the access configuration.
|
|
3378
|
+
"""
|
|
3379
|
+
type: NotRequired[pulumi.Input[_builtins.str]]
|
|
3380
|
+
"""
|
|
3381
|
+
The type of the access configuration.
|
|
3382
|
+
"""
|
|
3383
|
+
elif False:
|
|
3384
|
+
OceanLaunchSpecNetworkInterfaceAccessConfigArgsDict: TypeAlias = Mapping[str, Any]
|
|
3385
|
+
|
|
2188
3386
|
@pulumi.input_type
|
|
2189
3387
|
class OceanLaunchSpecNetworkInterfaceAccessConfigArgs:
|
|
2190
3388
|
def __init__(__self__, *,
|
|
2191
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
2192
|
-
type: Optional[pulumi.Input[str]] = None):
|
|
3389
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
3390
|
+
type: Optional[pulumi.Input[_builtins.str]] = None):
|
|
2193
3391
|
"""
|
|
2194
|
-
:param pulumi.Input[str] name: The name of the access configuration.
|
|
2195
|
-
:param pulumi.Input[str] type: The type of the access configuration.
|
|
3392
|
+
:param pulumi.Input[_builtins.str] name: The name of the access configuration.
|
|
3393
|
+
:param pulumi.Input[_builtins.str] type: The type of the access configuration.
|
|
2196
3394
|
"""
|
|
2197
3395
|
if name is not None:
|
|
2198
3396
|
pulumi.set(__self__, "name", name)
|
|
2199
3397
|
if type is not None:
|
|
2200
3398
|
pulumi.set(__self__, "type", type)
|
|
2201
3399
|
|
|
2202
|
-
@property
|
|
3400
|
+
@_builtins.property
|
|
2203
3401
|
@pulumi.getter
|
|
2204
|
-
def name(self) -> Optional[pulumi.Input[str]]:
|
|
3402
|
+
def name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2205
3403
|
"""
|
|
2206
3404
|
The name of the access configuration.
|
|
2207
3405
|
"""
|
|
2208
3406
|
return pulumi.get(self, "name")
|
|
2209
3407
|
|
|
2210
3408
|
@name.setter
|
|
2211
|
-
def name(self, value: Optional[pulumi.Input[str]]):
|
|
3409
|
+
def name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2212
3410
|
pulumi.set(self, "name", value)
|
|
2213
3411
|
|
|
2214
|
-
@property
|
|
3412
|
+
@_builtins.property
|
|
2215
3413
|
@pulumi.getter
|
|
2216
|
-
def type(self) -> Optional[pulumi.Input[str]]:
|
|
3414
|
+
def type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2217
3415
|
"""
|
|
2218
3416
|
The type of the access configuration.
|
|
2219
3417
|
"""
|
|
2220
3418
|
return pulumi.get(self, "type")
|
|
2221
3419
|
|
|
2222
3420
|
@type.setter
|
|
2223
|
-
def type(self, value: Optional[pulumi.Input[str]]):
|
|
3421
|
+
def type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2224
3422
|
pulumi.set(self, "type", value)
|
|
2225
3423
|
|
|
2226
3424
|
|
|
3425
|
+
if not MYPY:
|
|
3426
|
+
class OceanLaunchSpecNetworkInterfaceAliasIpRangeArgsDict(TypedDict):
|
|
3427
|
+
ip_cidr_range: pulumi.Input[_builtins.str]
|
|
3428
|
+
"""
|
|
3429
|
+
specify the IP address range in CIDR notation that can be used for the alias IP addresses associated with the imported node pool.
|
|
3430
|
+
"""
|
|
3431
|
+
subnetwork_range_name: pulumi.Input[_builtins.str]
|
|
3432
|
+
"""
|
|
3433
|
+
specify the IP address range for the subnet secondary IP range.
|
|
3434
|
+
"""
|
|
3435
|
+
elif False:
|
|
3436
|
+
OceanLaunchSpecNetworkInterfaceAliasIpRangeArgsDict: TypeAlias = Mapping[str, Any]
|
|
3437
|
+
|
|
2227
3438
|
@pulumi.input_type
|
|
2228
3439
|
class OceanLaunchSpecNetworkInterfaceAliasIpRangeArgs:
|
|
2229
3440
|
def __init__(__self__, *,
|
|
2230
|
-
ip_cidr_range: pulumi.Input[str],
|
|
2231
|
-
subnetwork_range_name: pulumi.Input[str]):
|
|
3441
|
+
ip_cidr_range: pulumi.Input[_builtins.str],
|
|
3442
|
+
subnetwork_range_name: pulumi.Input[_builtins.str]):
|
|
2232
3443
|
"""
|
|
2233
|
-
:param pulumi.Input[str] ip_cidr_range: specify the IP address range in CIDR notation that can be used for the alias IP addresses associated with the imported node pool.
|
|
2234
|
-
:param pulumi.Input[str] subnetwork_range_name: specify the IP address range for the subnet secondary IP range.
|
|
3444
|
+
:param pulumi.Input[_builtins.str] ip_cidr_range: specify the IP address range in CIDR notation that can be used for the alias IP addresses associated with the imported node pool.
|
|
3445
|
+
:param pulumi.Input[_builtins.str] subnetwork_range_name: specify the IP address range for the subnet secondary IP range.
|
|
2235
3446
|
"""
|
|
2236
3447
|
pulumi.set(__self__, "ip_cidr_range", ip_cidr_range)
|
|
2237
3448
|
pulumi.set(__self__, "subnetwork_range_name", subnetwork_range_name)
|
|
2238
3449
|
|
|
2239
|
-
@property
|
|
3450
|
+
@_builtins.property
|
|
2240
3451
|
@pulumi.getter(name="ipCidrRange")
|
|
2241
|
-
def ip_cidr_range(self) -> pulumi.Input[str]:
|
|
3452
|
+
def ip_cidr_range(self) -> pulumi.Input[_builtins.str]:
|
|
2242
3453
|
"""
|
|
2243
3454
|
specify the IP address range in CIDR notation that can be used for the alias IP addresses associated with the imported node pool.
|
|
2244
3455
|
"""
|
|
2245
3456
|
return pulumi.get(self, "ip_cidr_range")
|
|
2246
3457
|
|
|
2247
3458
|
@ip_cidr_range.setter
|
|
2248
|
-
def ip_cidr_range(self, value: pulumi.Input[str]):
|
|
3459
|
+
def ip_cidr_range(self, value: pulumi.Input[_builtins.str]):
|
|
2249
3460
|
pulumi.set(self, "ip_cidr_range", value)
|
|
2250
3461
|
|
|
2251
|
-
@property
|
|
3462
|
+
@_builtins.property
|
|
2252
3463
|
@pulumi.getter(name="subnetworkRangeName")
|
|
2253
|
-
def subnetwork_range_name(self) -> pulumi.Input[str]:
|
|
3464
|
+
def subnetwork_range_name(self) -> pulumi.Input[_builtins.str]:
|
|
2254
3465
|
"""
|
|
2255
3466
|
specify the IP address range for the subnet secondary IP range.
|
|
2256
3467
|
"""
|
|
2257
3468
|
return pulumi.get(self, "subnetwork_range_name")
|
|
2258
3469
|
|
|
2259
3470
|
@subnetwork_range_name.setter
|
|
2260
|
-
def subnetwork_range_name(self, value: pulumi.Input[str]):
|
|
3471
|
+
def subnetwork_range_name(self, value: pulumi.Input[_builtins.str]):
|
|
2261
3472
|
pulumi.set(self, "subnetwork_range_name", value)
|
|
2262
3473
|
|
|
2263
3474
|
|
|
3475
|
+
if not MYPY:
|
|
3476
|
+
class OceanLaunchSpecResourceLimitsArgsDict(TypedDict):
|
|
3477
|
+
max_instance_count: NotRequired[pulumi.Input[_builtins.int]]
|
|
3478
|
+
"""
|
|
3479
|
+
Option to set a maximum number of instances per virtual node group. Can be null. If set, the value must be greater than or equal to 0.
|
|
3480
|
+
"""
|
|
3481
|
+
min_instance_count: NotRequired[pulumi.Input[_builtins.int]]
|
|
3482
|
+
"""
|
|
3483
|
+
Option to set a minimum number of instances per virtual node group. Can be null. If set, the value must be greater than or equal to 0.
|
|
3484
|
+
"""
|
|
3485
|
+
elif False:
|
|
3486
|
+
OceanLaunchSpecResourceLimitsArgsDict: TypeAlias = Mapping[str, Any]
|
|
3487
|
+
|
|
2264
3488
|
@pulumi.input_type
|
|
2265
3489
|
class OceanLaunchSpecResourceLimitsArgs:
|
|
2266
3490
|
def __init__(__self__, *,
|
|
2267
|
-
max_instance_count: Optional[pulumi.Input[int]] = None,
|
|
2268
|
-
min_instance_count: Optional[pulumi.Input[int]] = None):
|
|
3491
|
+
max_instance_count: Optional[pulumi.Input[_builtins.int]] = None,
|
|
3492
|
+
min_instance_count: Optional[pulumi.Input[_builtins.int]] = None):
|
|
2269
3493
|
"""
|
|
2270
|
-
:param pulumi.Input[int] max_instance_count: Option to set a maximum number of instances per virtual node group. Can be null. If set, the value must be greater than or equal to 0.
|
|
2271
|
-
:param pulumi.Input[int] min_instance_count: Option to set a minimum number of instances per virtual node group. Can be null. If set, the value must be greater than or equal to 0.
|
|
3494
|
+
:param pulumi.Input[_builtins.int] max_instance_count: Option to set a maximum number of instances per virtual node group. Can be null. If set, the value must be greater than or equal to 0.
|
|
3495
|
+
:param pulumi.Input[_builtins.int] min_instance_count: Option to set a minimum number of instances per virtual node group. Can be null. If set, the value must be greater than or equal to 0.
|
|
2272
3496
|
"""
|
|
2273
3497
|
if max_instance_count is not None:
|
|
2274
3498
|
pulumi.set(__self__, "max_instance_count", max_instance_count)
|
|
2275
3499
|
if min_instance_count is not None:
|
|
2276
3500
|
pulumi.set(__self__, "min_instance_count", min_instance_count)
|
|
2277
3501
|
|
|
2278
|
-
@property
|
|
3502
|
+
@_builtins.property
|
|
2279
3503
|
@pulumi.getter(name="maxInstanceCount")
|
|
2280
|
-
def max_instance_count(self) -> Optional[pulumi.Input[int]]:
|
|
3504
|
+
def max_instance_count(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
2281
3505
|
"""
|
|
2282
3506
|
Option to set a maximum number of instances per virtual node group. Can be null. If set, the value must be greater than or equal to 0.
|
|
2283
3507
|
"""
|
|
2284
3508
|
return pulumi.get(self, "max_instance_count")
|
|
2285
3509
|
|
|
2286
3510
|
@max_instance_count.setter
|
|
2287
|
-
def max_instance_count(self, value: Optional[pulumi.Input[int]]):
|
|
3511
|
+
def max_instance_count(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
2288
3512
|
pulumi.set(self, "max_instance_count", value)
|
|
2289
3513
|
|
|
2290
|
-
@property
|
|
3514
|
+
@_builtins.property
|
|
2291
3515
|
@pulumi.getter(name="minInstanceCount")
|
|
2292
|
-
def min_instance_count(self) -> Optional[pulumi.Input[int]]:
|
|
3516
|
+
def min_instance_count(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
2293
3517
|
"""
|
|
2294
3518
|
Option to set a minimum number of instances per virtual node group. Can be null. If set, the value must be greater than or equal to 0.
|
|
2295
3519
|
"""
|
|
2296
3520
|
return pulumi.get(self, "min_instance_count")
|
|
2297
3521
|
|
|
2298
3522
|
@min_instance_count.setter
|
|
2299
|
-
def min_instance_count(self, value: Optional[pulumi.Input[int]]):
|
|
3523
|
+
def min_instance_count(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
2300
3524
|
pulumi.set(self, "min_instance_count", value)
|
|
2301
3525
|
|
|
2302
3526
|
|
|
3527
|
+
if not MYPY:
|
|
3528
|
+
class OceanLaunchSpecSchedulingTaskArgsDict(TypedDict):
|
|
3529
|
+
cron_expression: pulumi.Input[_builtins.str]
|
|
3530
|
+
"""
|
|
3531
|
+
A valid cron expression. For example : " * * * * * ". The cron job runs in UTC time and is in Unix cron format.
|
|
3532
|
+
"""
|
|
3533
|
+
is_enabled: pulumi.Input[_builtins.bool]
|
|
3534
|
+
"""
|
|
3535
|
+
Describes whether the task is enabled. When `true`, the task runs. When `false`, it does not run.
|
|
3536
|
+
"""
|
|
3537
|
+
task_type: pulumi.Input[_builtins.str]
|
|
3538
|
+
"""
|
|
3539
|
+
The activity that you are scheduling. Valid values: "manualHeadroomUpdate".
|
|
3540
|
+
"""
|
|
3541
|
+
task_headrooms: NotRequired[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecSchedulingTaskTaskHeadroomArgsDict']]]]
|
|
3542
|
+
"""
|
|
3543
|
+
The config of this scheduled task. Depends on the value of taskType.
|
|
3544
|
+
"""
|
|
3545
|
+
elif False:
|
|
3546
|
+
OceanLaunchSpecSchedulingTaskArgsDict: TypeAlias = Mapping[str, Any]
|
|
3547
|
+
|
|
2303
3548
|
@pulumi.input_type
|
|
2304
3549
|
class OceanLaunchSpecSchedulingTaskArgs:
|
|
2305
3550
|
def __init__(__self__, *,
|
|
2306
|
-
cron_expression: pulumi.Input[str],
|
|
2307
|
-
is_enabled: pulumi.Input[bool],
|
|
2308
|
-
task_type: pulumi.Input[str],
|
|
3551
|
+
cron_expression: pulumi.Input[_builtins.str],
|
|
3552
|
+
is_enabled: pulumi.Input[_builtins.bool],
|
|
3553
|
+
task_type: pulumi.Input[_builtins.str],
|
|
2309
3554
|
task_headrooms: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecSchedulingTaskTaskHeadroomArgs']]]] = None):
|
|
2310
3555
|
"""
|
|
2311
|
-
:param pulumi.Input[str] cron_expression: A valid cron expression. For example : " * * * * * ". The cron job runs in UTC time and is in Unix cron format.
|
|
2312
|
-
:param pulumi.Input[bool] is_enabled: Describes whether the task is enabled. When
|
|
2313
|
-
:param pulumi.Input[str] task_type: The activity that you are scheduling. Valid values: "manualHeadroomUpdate".
|
|
3556
|
+
:param pulumi.Input[_builtins.str] cron_expression: A valid cron expression. For example : " * * * * * ". The cron job runs in UTC time and is in Unix cron format.
|
|
3557
|
+
:param pulumi.Input[_builtins.bool] is_enabled: Describes whether the task is enabled. When `true`, the task runs. When `false`, it does not run.
|
|
3558
|
+
:param pulumi.Input[_builtins.str] task_type: The activity that you are scheduling. Valid values: "manualHeadroomUpdate".
|
|
2314
3559
|
:param pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecSchedulingTaskTaskHeadroomArgs']]] task_headrooms: The config of this scheduled task. Depends on the value of taskType.
|
|
2315
3560
|
"""
|
|
2316
3561
|
pulumi.set(__self__, "cron_expression", cron_expression)
|
|
@@ -2319,43 +3564,43 @@ class OceanLaunchSpecSchedulingTaskArgs:
|
|
|
2319
3564
|
if task_headrooms is not None:
|
|
2320
3565
|
pulumi.set(__self__, "task_headrooms", task_headrooms)
|
|
2321
3566
|
|
|
2322
|
-
@property
|
|
3567
|
+
@_builtins.property
|
|
2323
3568
|
@pulumi.getter(name="cronExpression")
|
|
2324
|
-
def cron_expression(self) -> pulumi.Input[str]:
|
|
3569
|
+
def cron_expression(self) -> pulumi.Input[_builtins.str]:
|
|
2325
3570
|
"""
|
|
2326
3571
|
A valid cron expression. For example : " * * * * * ". The cron job runs in UTC time and is in Unix cron format.
|
|
2327
3572
|
"""
|
|
2328
3573
|
return pulumi.get(self, "cron_expression")
|
|
2329
3574
|
|
|
2330
3575
|
@cron_expression.setter
|
|
2331
|
-
def cron_expression(self, value: pulumi.Input[str]):
|
|
3576
|
+
def cron_expression(self, value: pulumi.Input[_builtins.str]):
|
|
2332
3577
|
pulumi.set(self, "cron_expression", value)
|
|
2333
3578
|
|
|
2334
|
-
@property
|
|
3579
|
+
@_builtins.property
|
|
2335
3580
|
@pulumi.getter(name="isEnabled")
|
|
2336
|
-
def is_enabled(self) -> pulumi.Input[bool]:
|
|
3581
|
+
def is_enabled(self) -> pulumi.Input[_builtins.bool]:
|
|
2337
3582
|
"""
|
|
2338
|
-
Describes whether the task is enabled. When
|
|
3583
|
+
Describes whether the task is enabled. When `true`, the task runs. When `false`, it does not run.
|
|
2339
3584
|
"""
|
|
2340
3585
|
return pulumi.get(self, "is_enabled")
|
|
2341
3586
|
|
|
2342
3587
|
@is_enabled.setter
|
|
2343
|
-
def is_enabled(self, value: pulumi.Input[bool]):
|
|
3588
|
+
def is_enabled(self, value: pulumi.Input[_builtins.bool]):
|
|
2344
3589
|
pulumi.set(self, "is_enabled", value)
|
|
2345
3590
|
|
|
2346
|
-
@property
|
|
3591
|
+
@_builtins.property
|
|
2347
3592
|
@pulumi.getter(name="taskType")
|
|
2348
|
-
def task_type(self) -> pulumi.Input[str]:
|
|
3593
|
+
def task_type(self) -> pulumi.Input[_builtins.str]:
|
|
2349
3594
|
"""
|
|
2350
3595
|
The activity that you are scheduling. Valid values: "manualHeadroomUpdate".
|
|
2351
3596
|
"""
|
|
2352
3597
|
return pulumi.get(self, "task_type")
|
|
2353
3598
|
|
|
2354
3599
|
@task_type.setter
|
|
2355
|
-
def task_type(self, value: pulumi.Input[str]):
|
|
3600
|
+
def task_type(self, value: pulumi.Input[_builtins.str]):
|
|
2356
3601
|
pulumi.set(self, "task_type", value)
|
|
2357
3602
|
|
|
2358
|
-
@property
|
|
3603
|
+
@_builtins.property
|
|
2359
3604
|
@pulumi.getter(name="taskHeadrooms")
|
|
2360
3605
|
def task_headrooms(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecSchedulingTaskTaskHeadroomArgs']]]]:
|
|
2361
3606
|
"""
|
|
@@ -2368,18 +3613,39 @@ class OceanLaunchSpecSchedulingTaskArgs:
|
|
|
2368
3613
|
pulumi.set(self, "task_headrooms", value)
|
|
2369
3614
|
|
|
2370
3615
|
|
|
3616
|
+
if not MYPY:
|
|
3617
|
+
class OceanLaunchSpecSchedulingTaskTaskHeadroomArgsDict(TypedDict):
|
|
3618
|
+
num_of_units: pulumi.Input[_builtins.int]
|
|
3619
|
+
"""
|
|
3620
|
+
The number of units to retain as headroom, where each unit has the defined headroom CPU, memory and GPU.
|
|
3621
|
+
"""
|
|
3622
|
+
cpu_per_unit: NotRequired[pulumi.Input[_builtins.int]]
|
|
3623
|
+
"""
|
|
3624
|
+
Optionally configure the number of CPUs to allocate for each headroom unit. CPUs are denoted in millicores, where 1000 millicores = 1 vCPU.
|
|
3625
|
+
"""
|
|
3626
|
+
gpu_per_unit: NotRequired[pulumi.Input[_builtins.int]]
|
|
3627
|
+
"""
|
|
3628
|
+
Optionally configure the number of GPUS to allocate for each headroom unit.
|
|
3629
|
+
"""
|
|
3630
|
+
memory_per_unit: NotRequired[pulumi.Input[_builtins.int]]
|
|
3631
|
+
"""
|
|
3632
|
+
Optionally configure the amount of memory (MiB) to allocate for each headroom unit.
|
|
3633
|
+
"""
|
|
3634
|
+
elif False:
|
|
3635
|
+
OceanLaunchSpecSchedulingTaskTaskHeadroomArgsDict: TypeAlias = Mapping[str, Any]
|
|
3636
|
+
|
|
2371
3637
|
@pulumi.input_type
|
|
2372
3638
|
class OceanLaunchSpecSchedulingTaskTaskHeadroomArgs:
|
|
2373
3639
|
def __init__(__self__, *,
|
|
2374
|
-
num_of_units: pulumi.Input[int],
|
|
2375
|
-
cpu_per_unit: Optional[pulumi.Input[int]] = None,
|
|
2376
|
-
gpu_per_unit: Optional[pulumi.Input[int]] = None,
|
|
2377
|
-
memory_per_unit: Optional[pulumi.Input[int]] = None):
|
|
3640
|
+
num_of_units: pulumi.Input[_builtins.int],
|
|
3641
|
+
cpu_per_unit: Optional[pulumi.Input[_builtins.int]] = None,
|
|
3642
|
+
gpu_per_unit: Optional[pulumi.Input[_builtins.int]] = None,
|
|
3643
|
+
memory_per_unit: Optional[pulumi.Input[_builtins.int]] = None):
|
|
2378
3644
|
"""
|
|
2379
|
-
:param pulumi.Input[int] num_of_units: The number of units to retain as headroom, where each unit has the defined headroom CPU, memory and GPU.
|
|
2380
|
-
:param pulumi.Input[int] cpu_per_unit: Optionally configure the number of CPUs to allocate for each headroom unit. CPUs are denoted in millicores, where 1000 millicores = 1 vCPU.
|
|
2381
|
-
:param pulumi.Input[int] gpu_per_unit: Optionally configure the number of GPUS to allocate for each headroom unit.
|
|
2382
|
-
:param pulumi.Input[int] memory_per_unit: Optionally configure the amount of memory (MiB) to allocate for each headroom unit.
|
|
3645
|
+
:param pulumi.Input[_builtins.int] num_of_units: The number of units to retain as headroom, where each unit has the defined headroom CPU, memory and GPU.
|
|
3646
|
+
:param pulumi.Input[_builtins.int] cpu_per_unit: Optionally configure the number of CPUs to allocate for each headroom unit. CPUs are denoted in millicores, where 1000 millicores = 1 vCPU.
|
|
3647
|
+
:param pulumi.Input[_builtins.int] gpu_per_unit: Optionally configure the number of GPUS to allocate for each headroom unit.
|
|
3648
|
+
:param pulumi.Input[_builtins.int] memory_per_unit: Optionally configure the amount of memory (MiB) to allocate for each headroom unit.
|
|
2383
3649
|
"""
|
|
2384
3650
|
pulumi.set(__self__, "num_of_units", num_of_units)
|
|
2385
3651
|
if cpu_per_unit is not None:
|
|
@@ -2389,150 +3655,218 @@ class OceanLaunchSpecSchedulingTaskTaskHeadroomArgs:
|
|
|
2389
3655
|
if memory_per_unit is not None:
|
|
2390
3656
|
pulumi.set(__self__, "memory_per_unit", memory_per_unit)
|
|
2391
3657
|
|
|
2392
|
-
@property
|
|
3658
|
+
@_builtins.property
|
|
2393
3659
|
@pulumi.getter(name="numOfUnits")
|
|
2394
|
-
def num_of_units(self) -> pulumi.Input[int]:
|
|
3660
|
+
def num_of_units(self) -> pulumi.Input[_builtins.int]:
|
|
2395
3661
|
"""
|
|
2396
3662
|
The number of units to retain as headroom, where each unit has the defined headroom CPU, memory and GPU.
|
|
2397
3663
|
"""
|
|
2398
3664
|
return pulumi.get(self, "num_of_units")
|
|
2399
3665
|
|
|
2400
3666
|
@num_of_units.setter
|
|
2401
|
-
def num_of_units(self, value: pulumi.Input[int]):
|
|
3667
|
+
def num_of_units(self, value: pulumi.Input[_builtins.int]):
|
|
2402
3668
|
pulumi.set(self, "num_of_units", value)
|
|
2403
3669
|
|
|
2404
|
-
@property
|
|
3670
|
+
@_builtins.property
|
|
2405
3671
|
@pulumi.getter(name="cpuPerUnit")
|
|
2406
|
-
def cpu_per_unit(self) -> Optional[pulumi.Input[int]]:
|
|
3672
|
+
def cpu_per_unit(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
2407
3673
|
"""
|
|
2408
3674
|
Optionally configure the number of CPUs to allocate for each headroom unit. CPUs are denoted in millicores, where 1000 millicores = 1 vCPU.
|
|
2409
3675
|
"""
|
|
2410
3676
|
return pulumi.get(self, "cpu_per_unit")
|
|
2411
3677
|
|
|
2412
3678
|
@cpu_per_unit.setter
|
|
2413
|
-
def cpu_per_unit(self, value: Optional[pulumi.Input[int]]):
|
|
3679
|
+
def cpu_per_unit(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
2414
3680
|
pulumi.set(self, "cpu_per_unit", value)
|
|
2415
3681
|
|
|
2416
|
-
@property
|
|
3682
|
+
@_builtins.property
|
|
2417
3683
|
@pulumi.getter(name="gpuPerUnit")
|
|
2418
|
-
def gpu_per_unit(self) -> Optional[pulumi.Input[int]]:
|
|
3684
|
+
def gpu_per_unit(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
2419
3685
|
"""
|
|
2420
3686
|
Optionally configure the number of GPUS to allocate for each headroom unit.
|
|
2421
3687
|
"""
|
|
2422
3688
|
return pulumi.get(self, "gpu_per_unit")
|
|
2423
3689
|
|
|
2424
3690
|
@gpu_per_unit.setter
|
|
2425
|
-
def gpu_per_unit(self, value: Optional[pulumi.Input[int]]):
|
|
3691
|
+
def gpu_per_unit(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
2426
3692
|
pulumi.set(self, "gpu_per_unit", value)
|
|
2427
3693
|
|
|
2428
|
-
@property
|
|
3694
|
+
@_builtins.property
|
|
2429
3695
|
@pulumi.getter(name="memoryPerUnit")
|
|
2430
|
-
def memory_per_unit(self) -> Optional[pulumi.Input[int]]:
|
|
3696
|
+
def memory_per_unit(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
2431
3697
|
"""
|
|
2432
3698
|
Optionally configure the amount of memory (MiB) to allocate for each headroom unit.
|
|
2433
3699
|
"""
|
|
2434
3700
|
return pulumi.get(self, "memory_per_unit")
|
|
2435
3701
|
|
|
2436
3702
|
@memory_per_unit.setter
|
|
2437
|
-
def memory_per_unit(self, value: Optional[pulumi.Input[int]]):
|
|
3703
|
+
def memory_per_unit(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
2438
3704
|
pulumi.set(self, "memory_per_unit", value)
|
|
2439
3705
|
|
|
2440
3706
|
|
|
3707
|
+
if not MYPY:
|
|
3708
|
+
class OceanLaunchSpecShieldedInstanceConfigArgsDict(TypedDict):
|
|
3709
|
+
enable_integrity_monitoring: NotRequired[pulumi.Input[_builtins.bool]]
|
|
3710
|
+
"""
|
|
3711
|
+
Boolean. Enable the integrity monitoring parameter on the GCP instances.
|
|
3712
|
+
"""
|
|
3713
|
+
enable_secure_boot: NotRequired[pulumi.Input[_builtins.bool]]
|
|
3714
|
+
"""
|
|
3715
|
+
Boolean. Enable the secure boot parameter on the GCP instances.
|
|
3716
|
+
"""
|
|
3717
|
+
elif False:
|
|
3718
|
+
OceanLaunchSpecShieldedInstanceConfigArgsDict: TypeAlias = Mapping[str, Any]
|
|
3719
|
+
|
|
2441
3720
|
@pulumi.input_type
|
|
2442
3721
|
class OceanLaunchSpecShieldedInstanceConfigArgs:
|
|
2443
3722
|
def __init__(__self__, *,
|
|
2444
|
-
enable_integrity_monitoring: Optional[pulumi.Input[bool]] = None,
|
|
2445
|
-
enable_secure_boot: Optional[pulumi.Input[bool]] = None):
|
|
3723
|
+
enable_integrity_monitoring: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
3724
|
+
enable_secure_boot: Optional[pulumi.Input[_builtins.bool]] = None):
|
|
2446
3725
|
"""
|
|
2447
|
-
:param pulumi.Input[bool] enable_integrity_monitoring: Boolean. Enable the integrity monitoring parameter on the GCP instances.
|
|
2448
|
-
:param pulumi.Input[bool] enable_secure_boot: Boolean. Enable the secure boot parameter on the GCP instances.
|
|
3726
|
+
:param pulumi.Input[_builtins.bool] enable_integrity_monitoring: Boolean. Enable the integrity monitoring parameter on the GCP instances.
|
|
3727
|
+
:param pulumi.Input[_builtins.bool] enable_secure_boot: Boolean. Enable the secure boot parameter on the GCP instances.
|
|
2449
3728
|
"""
|
|
2450
3729
|
if enable_integrity_monitoring is not None:
|
|
2451
3730
|
pulumi.set(__self__, "enable_integrity_monitoring", enable_integrity_monitoring)
|
|
2452
3731
|
if enable_secure_boot is not None:
|
|
2453
3732
|
pulumi.set(__self__, "enable_secure_boot", enable_secure_boot)
|
|
2454
3733
|
|
|
2455
|
-
@property
|
|
3734
|
+
@_builtins.property
|
|
2456
3735
|
@pulumi.getter(name="enableIntegrityMonitoring")
|
|
2457
|
-
def enable_integrity_monitoring(self) -> Optional[pulumi.Input[bool]]:
|
|
3736
|
+
def enable_integrity_monitoring(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
2458
3737
|
"""
|
|
2459
3738
|
Boolean. Enable the integrity monitoring parameter on the GCP instances.
|
|
2460
3739
|
"""
|
|
2461
3740
|
return pulumi.get(self, "enable_integrity_monitoring")
|
|
2462
3741
|
|
|
2463
3742
|
@enable_integrity_monitoring.setter
|
|
2464
|
-
def enable_integrity_monitoring(self, value: Optional[pulumi.Input[bool]]):
|
|
3743
|
+
def enable_integrity_monitoring(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
2465
3744
|
pulumi.set(self, "enable_integrity_monitoring", value)
|
|
2466
3745
|
|
|
2467
|
-
@property
|
|
3746
|
+
@_builtins.property
|
|
2468
3747
|
@pulumi.getter(name="enableSecureBoot")
|
|
2469
|
-
def enable_secure_boot(self) -> Optional[pulumi.Input[bool]]:
|
|
3748
|
+
def enable_secure_boot(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
2470
3749
|
"""
|
|
2471
3750
|
Boolean. Enable the secure boot parameter on the GCP instances.
|
|
2472
3751
|
"""
|
|
2473
3752
|
return pulumi.get(self, "enable_secure_boot")
|
|
2474
3753
|
|
|
2475
3754
|
@enable_secure_boot.setter
|
|
2476
|
-
def enable_secure_boot(self, value: Optional[pulumi.Input[bool]]):
|
|
3755
|
+
def enable_secure_boot(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
2477
3756
|
pulumi.set(self, "enable_secure_boot", value)
|
|
2478
3757
|
|
|
2479
3758
|
|
|
3759
|
+
if not MYPY:
|
|
3760
|
+
class OceanLaunchSpecStorageArgsDict(TypedDict):
|
|
3761
|
+
local_ssd_count: NotRequired[pulumi.Input[_builtins.int]]
|
|
3762
|
+
"""
|
|
3763
|
+
Defines the number of local SSDs to be attached per node for this VNG.
|
|
3764
|
+
"""
|
|
3765
|
+
elif False:
|
|
3766
|
+
OceanLaunchSpecStorageArgsDict: TypeAlias = Mapping[str, Any]
|
|
3767
|
+
|
|
2480
3768
|
@pulumi.input_type
|
|
2481
3769
|
class OceanLaunchSpecStorageArgs:
|
|
2482
3770
|
def __init__(__self__, *,
|
|
2483
|
-
local_ssd_count: Optional[pulumi.Input[int]] = None):
|
|
3771
|
+
local_ssd_count: Optional[pulumi.Input[_builtins.int]] = None):
|
|
2484
3772
|
"""
|
|
2485
|
-
:param pulumi.Input[int] local_ssd_count: Defines the number of local SSDs to be attached per node for this VNG.
|
|
3773
|
+
:param pulumi.Input[_builtins.int] local_ssd_count: Defines the number of local SSDs to be attached per node for this VNG.
|
|
2486
3774
|
"""
|
|
2487
3775
|
if local_ssd_count is not None:
|
|
2488
3776
|
pulumi.set(__self__, "local_ssd_count", local_ssd_count)
|
|
2489
3777
|
|
|
2490
|
-
@property
|
|
3778
|
+
@_builtins.property
|
|
2491
3779
|
@pulumi.getter(name="localSsdCount")
|
|
2492
|
-
def local_ssd_count(self) -> Optional[pulumi.Input[int]]:
|
|
3780
|
+
def local_ssd_count(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
2493
3781
|
"""
|
|
2494
3782
|
Defines the number of local SSDs to be attached per node for this VNG.
|
|
2495
3783
|
"""
|
|
2496
3784
|
return pulumi.get(self, "local_ssd_count")
|
|
2497
3785
|
|
|
2498
3786
|
@local_ssd_count.setter
|
|
2499
|
-
def local_ssd_count(self, value: Optional[pulumi.Input[int]]):
|
|
3787
|
+
def local_ssd_count(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
2500
3788
|
pulumi.set(self, "local_ssd_count", value)
|
|
2501
3789
|
|
|
2502
3790
|
|
|
3791
|
+
if not MYPY:
|
|
3792
|
+
class OceanLaunchSpecStrategyArgsDict(TypedDict):
|
|
3793
|
+
preemptible_percentage: NotRequired[pulumi.Input[_builtins.int]]
|
|
3794
|
+
"""
|
|
3795
|
+
Defines the desired preemptible percentage for this launch specification.
|
|
3796
|
+
"""
|
|
3797
|
+
scaling_orientation: NotRequired[pulumi.Input[_builtins.str]]
|
|
3798
|
+
"""
|
|
3799
|
+
Valid Values: `"cost", "availability", "balanced"`. Set this value to control the approach that Ocean takes when launching nodes.
|
|
3800
|
+
"""
|
|
3801
|
+
elif False:
|
|
3802
|
+
OceanLaunchSpecStrategyArgsDict: TypeAlias = Mapping[str, Any]
|
|
3803
|
+
|
|
2503
3804
|
@pulumi.input_type
|
|
2504
3805
|
class OceanLaunchSpecStrategyArgs:
|
|
2505
3806
|
def __init__(__self__, *,
|
|
2506
|
-
preemptible_percentage: Optional[pulumi.Input[int]] = None
|
|
3807
|
+
preemptible_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
3808
|
+
scaling_orientation: Optional[pulumi.Input[_builtins.str]] = None):
|
|
2507
3809
|
"""
|
|
2508
|
-
:param pulumi.Input[int] preemptible_percentage: Defines the desired preemptible percentage for this launch specification.
|
|
3810
|
+
:param pulumi.Input[_builtins.int] preemptible_percentage: Defines the desired preemptible percentage for this launch specification.
|
|
3811
|
+
:param pulumi.Input[_builtins.str] scaling_orientation: Valid Values: `"cost", "availability", "balanced"`. Set this value to control the approach that Ocean takes when launching nodes.
|
|
2509
3812
|
"""
|
|
2510
3813
|
if preemptible_percentage is not None:
|
|
2511
3814
|
pulumi.set(__self__, "preemptible_percentage", preemptible_percentage)
|
|
3815
|
+
if scaling_orientation is not None:
|
|
3816
|
+
pulumi.set(__self__, "scaling_orientation", scaling_orientation)
|
|
2512
3817
|
|
|
2513
|
-
@property
|
|
3818
|
+
@_builtins.property
|
|
2514
3819
|
@pulumi.getter(name="preemptiblePercentage")
|
|
2515
|
-
def preemptible_percentage(self) -> Optional[pulumi.Input[int]]:
|
|
3820
|
+
def preemptible_percentage(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
2516
3821
|
"""
|
|
2517
3822
|
Defines the desired preemptible percentage for this launch specification.
|
|
2518
3823
|
"""
|
|
2519
3824
|
return pulumi.get(self, "preemptible_percentage")
|
|
2520
3825
|
|
|
2521
3826
|
@preemptible_percentage.setter
|
|
2522
|
-
def preemptible_percentage(self, value: Optional[pulumi.Input[int]]):
|
|
3827
|
+
def preemptible_percentage(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
2523
3828
|
pulumi.set(self, "preemptible_percentage", value)
|
|
2524
3829
|
|
|
3830
|
+
@_builtins.property
|
|
3831
|
+
@pulumi.getter(name="scalingOrientation")
|
|
3832
|
+
def scaling_orientation(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
3833
|
+
"""
|
|
3834
|
+
Valid Values: `"cost", "availability", "balanced"`. Set this value to control the approach that Ocean takes when launching nodes.
|
|
3835
|
+
"""
|
|
3836
|
+
return pulumi.get(self, "scaling_orientation")
|
|
3837
|
+
|
|
3838
|
+
@scaling_orientation.setter
|
|
3839
|
+
def scaling_orientation(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
3840
|
+
pulumi.set(self, "scaling_orientation", value)
|
|
3841
|
+
|
|
3842
|
+
|
|
3843
|
+
if not MYPY:
|
|
3844
|
+
class OceanLaunchSpecTaintArgsDict(TypedDict):
|
|
3845
|
+
effect: NotRequired[pulumi.Input[_builtins.str]]
|
|
3846
|
+
"""
|
|
3847
|
+
The effect of the taint. Valid values: `"NoSchedule"`, `"PreferNoSchedule"`, `"NoExecute"`.
|
|
3848
|
+
"""
|
|
3849
|
+
key: NotRequired[pulumi.Input[_builtins.str]]
|
|
3850
|
+
"""
|
|
3851
|
+
The taint key.
|
|
3852
|
+
"""
|
|
3853
|
+
value: NotRequired[pulumi.Input[_builtins.str]]
|
|
3854
|
+
"""
|
|
3855
|
+
The taint value.
|
|
3856
|
+
"""
|
|
3857
|
+
elif False:
|
|
3858
|
+
OceanLaunchSpecTaintArgsDict: TypeAlias = Mapping[str, Any]
|
|
2525
3859
|
|
|
2526
3860
|
@pulumi.input_type
|
|
2527
3861
|
class OceanLaunchSpecTaintArgs:
|
|
2528
3862
|
def __init__(__self__, *,
|
|
2529
|
-
effect: Optional[pulumi.Input[str]] = None,
|
|
2530
|
-
key: Optional[pulumi.Input[str]] = None,
|
|
2531
|
-
value: Optional[pulumi.Input[str]] = None):
|
|
3863
|
+
effect: Optional[pulumi.Input[_builtins.str]] = None,
|
|
3864
|
+
key: Optional[pulumi.Input[_builtins.str]] = None,
|
|
3865
|
+
value: Optional[pulumi.Input[_builtins.str]] = None):
|
|
2532
3866
|
"""
|
|
2533
|
-
:param pulumi.Input[str] effect: The effect of the taint. Valid values: `"NoSchedule"`, `"PreferNoSchedule"`, `"NoExecute"`.
|
|
2534
|
-
:param pulumi.Input[str] key: The taint key.
|
|
2535
|
-
:param pulumi.Input[str] value: The taint value.
|
|
3867
|
+
:param pulumi.Input[_builtins.str] effect: The effect of the taint. Valid values: `"NoSchedule"`, `"PreferNoSchedule"`, `"NoExecute"`.
|
|
3868
|
+
:param pulumi.Input[_builtins.str] key: The taint key.
|
|
3869
|
+
:param pulumi.Input[_builtins.str] value: The taint value.
|
|
2536
3870
|
"""
|
|
2537
3871
|
if effect is not None:
|
|
2538
3872
|
pulumi.set(__self__, "effect", effect)
|
|
@@ -2541,69 +3875,82 @@ class OceanLaunchSpecTaintArgs:
|
|
|
2541
3875
|
if value is not None:
|
|
2542
3876
|
pulumi.set(__self__, "value", value)
|
|
2543
3877
|
|
|
2544
|
-
@property
|
|
3878
|
+
@_builtins.property
|
|
2545
3879
|
@pulumi.getter
|
|
2546
|
-
def effect(self) -> Optional[pulumi.Input[str]]:
|
|
3880
|
+
def effect(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2547
3881
|
"""
|
|
2548
3882
|
The effect of the taint. Valid values: `"NoSchedule"`, `"PreferNoSchedule"`, `"NoExecute"`.
|
|
2549
3883
|
"""
|
|
2550
3884
|
return pulumi.get(self, "effect")
|
|
2551
3885
|
|
|
2552
3886
|
@effect.setter
|
|
2553
|
-
def effect(self, value: Optional[pulumi.Input[str]]):
|
|
3887
|
+
def effect(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2554
3888
|
pulumi.set(self, "effect", value)
|
|
2555
3889
|
|
|
2556
|
-
@property
|
|
3890
|
+
@_builtins.property
|
|
2557
3891
|
@pulumi.getter
|
|
2558
|
-
def key(self) -> Optional[pulumi.Input[str]]:
|
|
3892
|
+
def key(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2559
3893
|
"""
|
|
2560
3894
|
The taint key.
|
|
2561
3895
|
"""
|
|
2562
3896
|
return pulumi.get(self, "key")
|
|
2563
3897
|
|
|
2564
3898
|
@key.setter
|
|
2565
|
-
def key(self, value: Optional[pulumi.Input[str]]):
|
|
3899
|
+
def key(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2566
3900
|
pulumi.set(self, "key", value)
|
|
2567
3901
|
|
|
2568
|
-
@property
|
|
3902
|
+
@_builtins.property
|
|
2569
3903
|
@pulumi.getter
|
|
2570
|
-
def value(self) -> Optional[pulumi.Input[str]]:
|
|
3904
|
+
def value(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2571
3905
|
"""
|
|
2572
3906
|
The taint value.
|
|
2573
3907
|
"""
|
|
2574
3908
|
return pulumi.get(self, "value")
|
|
2575
3909
|
|
|
2576
3910
|
@value.setter
|
|
2577
|
-
def value(self, value: Optional[pulumi.Input[str]]):
|
|
3911
|
+
def value(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2578
3912
|
pulumi.set(self, "value", value)
|
|
2579
3913
|
|
|
2580
3914
|
|
|
3915
|
+
if not MYPY:
|
|
3916
|
+
class OceanLaunchSpecUpdatePolicyArgsDict(TypedDict):
|
|
3917
|
+
should_roll: pulumi.Input[_builtins.bool]
|
|
3918
|
+
"""
|
|
3919
|
+
Enables the roll.
|
|
3920
|
+
"""
|
|
3921
|
+
roll_config: NotRequired[pulumi.Input['OceanLaunchSpecUpdatePolicyRollConfigArgsDict']]
|
|
3922
|
+
"""
|
|
3923
|
+
Holds the roll configuration.
|
|
3924
|
+
"""
|
|
3925
|
+
elif False:
|
|
3926
|
+
OceanLaunchSpecUpdatePolicyArgsDict: TypeAlias = Mapping[str, Any]
|
|
3927
|
+
|
|
2581
3928
|
@pulumi.input_type
|
|
2582
3929
|
class OceanLaunchSpecUpdatePolicyArgs:
|
|
2583
3930
|
def __init__(__self__, *,
|
|
2584
|
-
should_roll: pulumi.Input[bool],
|
|
3931
|
+
should_roll: pulumi.Input[_builtins.bool],
|
|
2585
3932
|
roll_config: Optional[pulumi.Input['OceanLaunchSpecUpdatePolicyRollConfigArgs']] = None):
|
|
2586
3933
|
"""
|
|
2587
|
-
:param pulumi.Input[bool] should_roll: Enables the roll.
|
|
3934
|
+
:param pulumi.Input[_builtins.bool] should_roll: Enables the roll.
|
|
2588
3935
|
:param pulumi.Input['OceanLaunchSpecUpdatePolicyRollConfigArgs'] roll_config: Holds the roll configuration.
|
|
2589
3936
|
"""
|
|
2590
3937
|
pulumi.set(__self__, "should_roll", should_roll)
|
|
2591
3938
|
if roll_config is not None:
|
|
2592
3939
|
pulumi.set(__self__, "roll_config", roll_config)
|
|
2593
3940
|
|
|
2594
|
-
@property
|
|
3941
|
+
@_builtins.property
|
|
2595
3942
|
@pulumi.getter(name="shouldRoll")
|
|
2596
|
-
def should_roll(self) -> pulumi.Input[bool]:
|
|
3943
|
+
def should_roll(self) -> pulumi.Input[_builtins.bool]:
|
|
2597
3944
|
"""
|
|
2598
3945
|
Enables the roll.
|
|
2599
3946
|
"""
|
|
2600
3947
|
return pulumi.get(self, "should_roll")
|
|
2601
3948
|
|
|
2602
3949
|
@should_roll.setter
|
|
2603
|
-
def should_roll(self, value: pulumi.Input[bool]):
|
|
3950
|
+
def should_roll(self, value: pulumi.Input[_builtins.bool]):
|
|
2604
3951
|
pulumi.set(self, "should_roll", value)
|
|
2605
3952
|
|
|
2606
|
-
@property
|
|
3953
|
+
@_builtins.property
|
|
2607
3954
|
@pulumi.getter(name="rollConfig")
|
|
2608
3955
|
def roll_config(self) -> Optional[pulumi.Input['OceanLaunchSpecUpdatePolicyRollConfigArgs']]:
|
|
2609
3956
|
"""
|
|
@@ -2616,25 +3963,34 @@ class OceanLaunchSpecUpdatePolicyArgs:
|
|
|
2616
3963
|
pulumi.set(self, "roll_config", value)
|
|
2617
3964
|
|
|
2618
3965
|
|
|
3966
|
+
if not MYPY:
|
|
3967
|
+
class OceanLaunchSpecUpdatePolicyRollConfigArgsDict(TypedDict):
|
|
3968
|
+
batch_size_percentage: pulumi.Input[_builtins.int]
|
|
3969
|
+
"""
|
|
3970
|
+
Sets the percentage of the instances to deploy in each batch.
|
|
3971
|
+
"""
|
|
3972
|
+
elif False:
|
|
3973
|
+
OceanLaunchSpecUpdatePolicyRollConfigArgsDict: TypeAlias = Mapping[str, Any]
|
|
3974
|
+
|
|
2619
3975
|
@pulumi.input_type
|
|
2620
3976
|
class OceanLaunchSpecUpdatePolicyRollConfigArgs:
|
|
2621
3977
|
def __init__(__self__, *,
|
|
2622
|
-
batch_size_percentage: pulumi.Input[int]):
|
|
3978
|
+
batch_size_percentage: pulumi.Input[_builtins.int]):
|
|
2623
3979
|
"""
|
|
2624
|
-
:param pulumi.Input[int] batch_size_percentage: Sets the percentage of the instances to deploy in each batch.
|
|
3980
|
+
:param pulumi.Input[_builtins.int] batch_size_percentage: Sets the percentage of the instances to deploy in each batch.
|
|
2625
3981
|
"""
|
|
2626
3982
|
pulumi.set(__self__, "batch_size_percentage", batch_size_percentage)
|
|
2627
3983
|
|
|
2628
|
-
@property
|
|
3984
|
+
@_builtins.property
|
|
2629
3985
|
@pulumi.getter(name="batchSizePercentage")
|
|
2630
|
-
def batch_size_percentage(self) -> pulumi.Input[int]:
|
|
3986
|
+
def batch_size_percentage(self) -> pulumi.Input[_builtins.int]:
|
|
2631
3987
|
"""
|
|
2632
3988
|
Sets the percentage of the instances to deploy in each batch.
|
|
2633
3989
|
"""
|
|
2634
3990
|
return pulumi.get(self, "batch_size_percentage")
|
|
2635
3991
|
|
|
2636
3992
|
@batch_size_percentage.setter
|
|
2637
|
-
def batch_size_percentage(self, value: pulumi.Input[int]):
|
|
3993
|
+
def batch_size_percentage(self, value: pulumi.Input[_builtins.int]):
|
|
2638
3994
|
pulumi.set(self, "batch_size_percentage", value)
|
|
2639
3995
|
|
|
2640
3996
|
|