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