pulumi-spotinst 3.123.1a1753328543__py3-none-any.whl → 3.124.0__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Potentially problematic release.
This version of pulumi-spotinst might be problematic. Click here for more details.
- pulumi_spotinst/__init__.py +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 +578 -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.123.1a1753328543.dist-info → pulumi_spotinst-3.124.0.dist-info}/METADATA +1 -1
- pulumi_spotinst-3.124.0.dist-info/RECORD +77 -0
- pulumi_spotinst-3.123.1a1753328543.dist-info/RECORD +0 -77
- {pulumi_spotinst-3.123.1a1753328543.dist-info → pulumi_spotinst-3.124.0.dist-info}/WHEEL +0 -0
- {pulumi_spotinst-3.123.1a1753328543.dist-info → pulumi_spotinst-3.124.0.dist-info}/top_level.txt +0 -0
pulumi_spotinst/ecs/_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
|
|
@@ -84,11 +83,11 @@ MYPY = False
|
|
|
84
83
|
|
|
85
84
|
if not MYPY:
|
|
86
85
|
class OceanAutoscalerArgsDict(TypedDict):
|
|
87
|
-
auto_headroom_percentage: NotRequired[pulumi.Input[
|
|
86
|
+
auto_headroom_percentage: NotRequired[pulumi.Input[_builtins.int]]
|
|
88
87
|
"""
|
|
89
88
|
The auto-headroom percentage. Set a number between 0-200 to control the headroom % of the cluster. Relevant when `isAutoConfig`= true.
|
|
90
89
|
"""
|
|
91
|
-
cooldown: NotRequired[pulumi.Input[
|
|
90
|
+
cooldown: NotRequired[pulumi.Input[_builtins.int]]
|
|
92
91
|
"""
|
|
93
92
|
Cooldown period between scaling actions.
|
|
94
93
|
"""
|
|
@@ -96,7 +95,7 @@ if not MYPY:
|
|
|
96
95
|
"""
|
|
97
96
|
Auto Scaling scale down operations.
|
|
98
97
|
"""
|
|
99
|
-
enable_automatic_and_manual_headroom: NotRequired[pulumi.Input[
|
|
98
|
+
enable_automatic_and_manual_headroom: NotRequired[pulumi.Input[_builtins.bool]]
|
|
100
99
|
"""
|
|
101
100
|
When set to true, both automatic and per custom launch specification manual headroom to be saved concurrently and independently in the cluster. prerequisite: isAutoConfig must be true
|
|
102
101
|
"""
|
|
@@ -104,11 +103,11 @@ if not MYPY:
|
|
|
104
103
|
"""
|
|
105
104
|
Spare resource capacity management enabling fast assignment of tasks without waiting for new resources to launch.
|
|
106
105
|
"""
|
|
107
|
-
is_auto_config: NotRequired[pulumi.Input[
|
|
106
|
+
is_auto_config: NotRequired[pulumi.Input[_builtins.bool]]
|
|
108
107
|
"""
|
|
109
108
|
Automatically configure and optimize headroom resources.
|
|
110
109
|
"""
|
|
111
|
-
is_enabled: NotRequired[pulumi.Input[
|
|
110
|
+
is_enabled: NotRequired[pulumi.Input[_builtins.bool]]
|
|
112
111
|
"""
|
|
113
112
|
Enable the Ocean ECS autoscaler.
|
|
114
113
|
"""
|
|
@@ -116,7 +115,7 @@ if not MYPY:
|
|
|
116
115
|
"""
|
|
117
116
|
Optionally set upper and lower bounds on the resource usage of the cluster.
|
|
118
117
|
"""
|
|
119
|
-
should_scale_down_non_service_tasks: NotRequired[pulumi.Input[
|
|
118
|
+
should_scale_down_non_service_tasks: NotRequired[pulumi.Input[_builtins.bool]]
|
|
120
119
|
"""
|
|
121
120
|
Option to scale down non-service tasks. If not set, Ocean does not scale down standalone tasks.
|
|
122
121
|
"""
|
|
@@ -126,25 +125,25 @@ elif False:
|
|
|
126
125
|
@pulumi.input_type
|
|
127
126
|
class OceanAutoscalerArgs:
|
|
128
127
|
def __init__(__self__, *,
|
|
129
|
-
auto_headroom_percentage: Optional[pulumi.Input[
|
|
130
|
-
cooldown: Optional[pulumi.Input[
|
|
128
|
+
auto_headroom_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
129
|
+
cooldown: Optional[pulumi.Input[_builtins.int]] = None,
|
|
131
130
|
down: Optional[pulumi.Input['OceanAutoscalerDownArgs']] = None,
|
|
132
|
-
enable_automatic_and_manual_headroom: Optional[pulumi.Input[
|
|
131
|
+
enable_automatic_and_manual_headroom: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
133
132
|
headroom: Optional[pulumi.Input['OceanAutoscalerHeadroomArgs']] = None,
|
|
134
|
-
is_auto_config: Optional[pulumi.Input[
|
|
135
|
-
is_enabled: Optional[pulumi.Input[
|
|
133
|
+
is_auto_config: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
134
|
+
is_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
136
135
|
resource_limits: Optional[pulumi.Input['OceanAutoscalerResourceLimitsArgs']] = None,
|
|
137
|
-
should_scale_down_non_service_tasks: Optional[pulumi.Input[
|
|
136
|
+
should_scale_down_non_service_tasks: Optional[pulumi.Input[_builtins.bool]] = None):
|
|
138
137
|
"""
|
|
139
|
-
:param pulumi.Input[
|
|
140
|
-
:param pulumi.Input[
|
|
138
|
+
:param pulumi.Input[_builtins.int] auto_headroom_percentage: The auto-headroom percentage. Set a number between 0-200 to control the headroom % of the cluster. Relevant when `isAutoConfig`= true.
|
|
139
|
+
:param pulumi.Input[_builtins.int] cooldown: Cooldown period between scaling actions.
|
|
141
140
|
:param pulumi.Input['OceanAutoscalerDownArgs'] down: Auto Scaling scale down operations.
|
|
142
|
-
:param pulumi.Input[
|
|
141
|
+
:param pulumi.Input[_builtins.bool] enable_automatic_and_manual_headroom: When set to true, both automatic and per custom launch specification manual headroom to be saved concurrently and independently in the cluster. prerequisite: isAutoConfig must be true
|
|
143
142
|
:param pulumi.Input['OceanAutoscalerHeadroomArgs'] headroom: Spare resource capacity management enabling fast assignment of tasks without waiting for new resources to launch.
|
|
144
|
-
:param pulumi.Input[
|
|
145
|
-
:param pulumi.Input[
|
|
143
|
+
:param pulumi.Input[_builtins.bool] is_auto_config: Automatically configure and optimize headroom resources.
|
|
144
|
+
:param pulumi.Input[_builtins.bool] is_enabled: Enable the Ocean ECS autoscaler.
|
|
146
145
|
:param pulumi.Input['OceanAutoscalerResourceLimitsArgs'] resource_limits: Optionally set upper and lower bounds on the resource usage of the cluster.
|
|
147
|
-
:param pulumi.Input[
|
|
146
|
+
:param pulumi.Input[_builtins.bool] should_scale_down_non_service_tasks: Option to scale down non-service tasks. If not set, Ocean does not scale down standalone tasks.
|
|
148
147
|
"""
|
|
149
148
|
if auto_headroom_percentage is not None:
|
|
150
149
|
pulumi.set(__self__, "auto_headroom_percentage", auto_headroom_percentage)
|
|
@@ -165,31 +164,31 @@ class OceanAutoscalerArgs:
|
|
|
165
164
|
if should_scale_down_non_service_tasks is not None:
|
|
166
165
|
pulumi.set(__self__, "should_scale_down_non_service_tasks", should_scale_down_non_service_tasks)
|
|
167
166
|
|
|
168
|
-
@property
|
|
167
|
+
@_builtins.property
|
|
169
168
|
@pulumi.getter(name="autoHeadroomPercentage")
|
|
170
|
-
def auto_headroom_percentage(self) -> Optional[pulumi.Input[
|
|
169
|
+
def auto_headroom_percentage(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
171
170
|
"""
|
|
172
171
|
The auto-headroom percentage. Set a number between 0-200 to control the headroom % of the cluster. Relevant when `isAutoConfig`= true.
|
|
173
172
|
"""
|
|
174
173
|
return pulumi.get(self, "auto_headroom_percentage")
|
|
175
174
|
|
|
176
175
|
@auto_headroom_percentage.setter
|
|
177
|
-
def auto_headroom_percentage(self, value: Optional[pulumi.Input[
|
|
176
|
+
def auto_headroom_percentage(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
178
177
|
pulumi.set(self, "auto_headroom_percentage", value)
|
|
179
178
|
|
|
180
|
-
@property
|
|
179
|
+
@_builtins.property
|
|
181
180
|
@pulumi.getter
|
|
182
|
-
def cooldown(self) -> Optional[pulumi.Input[
|
|
181
|
+
def cooldown(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
183
182
|
"""
|
|
184
183
|
Cooldown period between scaling actions.
|
|
185
184
|
"""
|
|
186
185
|
return pulumi.get(self, "cooldown")
|
|
187
186
|
|
|
188
187
|
@cooldown.setter
|
|
189
|
-
def cooldown(self, value: Optional[pulumi.Input[
|
|
188
|
+
def cooldown(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
190
189
|
pulumi.set(self, "cooldown", value)
|
|
191
190
|
|
|
192
|
-
@property
|
|
191
|
+
@_builtins.property
|
|
193
192
|
@pulumi.getter
|
|
194
193
|
def down(self) -> Optional[pulumi.Input['OceanAutoscalerDownArgs']]:
|
|
195
194
|
"""
|
|
@@ -201,19 +200,19 @@ class OceanAutoscalerArgs:
|
|
|
201
200
|
def down(self, value: Optional[pulumi.Input['OceanAutoscalerDownArgs']]):
|
|
202
201
|
pulumi.set(self, "down", value)
|
|
203
202
|
|
|
204
|
-
@property
|
|
203
|
+
@_builtins.property
|
|
205
204
|
@pulumi.getter(name="enableAutomaticAndManualHeadroom")
|
|
206
|
-
def enable_automatic_and_manual_headroom(self) -> Optional[pulumi.Input[
|
|
205
|
+
def enable_automatic_and_manual_headroom(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
207
206
|
"""
|
|
208
207
|
When set to true, both automatic and per custom launch specification manual headroom to be saved concurrently and independently in the cluster. prerequisite: isAutoConfig must be true
|
|
209
208
|
"""
|
|
210
209
|
return pulumi.get(self, "enable_automatic_and_manual_headroom")
|
|
211
210
|
|
|
212
211
|
@enable_automatic_and_manual_headroom.setter
|
|
213
|
-
def enable_automatic_and_manual_headroom(self, value: Optional[pulumi.Input[
|
|
212
|
+
def enable_automatic_and_manual_headroom(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
214
213
|
pulumi.set(self, "enable_automatic_and_manual_headroom", value)
|
|
215
214
|
|
|
216
|
-
@property
|
|
215
|
+
@_builtins.property
|
|
217
216
|
@pulumi.getter
|
|
218
217
|
def headroom(self) -> Optional[pulumi.Input['OceanAutoscalerHeadroomArgs']]:
|
|
219
218
|
"""
|
|
@@ -225,31 +224,31 @@ class OceanAutoscalerArgs:
|
|
|
225
224
|
def headroom(self, value: Optional[pulumi.Input['OceanAutoscalerHeadroomArgs']]):
|
|
226
225
|
pulumi.set(self, "headroom", value)
|
|
227
226
|
|
|
228
|
-
@property
|
|
227
|
+
@_builtins.property
|
|
229
228
|
@pulumi.getter(name="isAutoConfig")
|
|
230
|
-
def is_auto_config(self) -> Optional[pulumi.Input[
|
|
229
|
+
def is_auto_config(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
231
230
|
"""
|
|
232
231
|
Automatically configure and optimize headroom resources.
|
|
233
232
|
"""
|
|
234
233
|
return pulumi.get(self, "is_auto_config")
|
|
235
234
|
|
|
236
235
|
@is_auto_config.setter
|
|
237
|
-
def is_auto_config(self, value: Optional[pulumi.Input[
|
|
236
|
+
def is_auto_config(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
238
237
|
pulumi.set(self, "is_auto_config", value)
|
|
239
238
|
|
|
240
|
-
@property
|
|
239
|
+
@_builtins.property
|
|
241
240
|
@pulumi.getter(name="isEnabled")
|
|
242
|
-
def is_enabled(self) -> Optional[pulumi.Input[
|
|
241
|
+
def is_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
243
242
|
"""
|
|
244
243
|
Enable the Ocean ECS autoscaler.
|
|
245
244
|
"""
|
|
246
245
|
return pulumi.get(self, "is_enabled")
|
|
247
246
|
|
|
248
247
|
@is_enabled.setter
|
|
249
|
-
def is_enabled(self, value: Optional[pulumi.Input[
|
|
248
|
+
def is_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
250
249
|
pulumi.set(self, "is_enabled", value)
|
|
251
250
|
|
|
252
|
-
@property
|
|
251
|
+
@_builtins.property
|
|
253
252
|
@pulumi.getter(name="resourceLimits")
|
|
254
253
|
def resource_limits(self) -> Optional[pulumi.Input['OceanAutoscalerResourceLimitsArgs']]:
|
|
255
254
|
"""
|
|
@@ -261,22 +260,22 @@ class OceanAutoscalerArgs:
|
|
|
261
260
|
def resource_limits(self, value: Optional[pulumi.Input['OceanAutoscalerResourceLimitsArgs']]):
|
|
262
261
|
pulumi.set(self, "resource_limits", value)
|
|
263
262
|
|
|
264
|
-
@property
|
|
263
|
+
@_builtins.property
|
|
265
264
|
@pulumi.getter(name="shouldScaleDownNonServiceTasks")
|
|
266
|
-
def should_scale_down_non_service_tasks(self) -> Optional[pulumi.Input[
|
|
265
|
+
def should_scale_down_non_service_tasks(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
267
266
|
"""
|
|
268
267
|
Option to scale down non-service tasks. If not set, Ocean does not scale down standalone tasks.
|
|
269
268
|
"""
|
|
270
269
|
return pulumi.get(self, "should_scale_down_non_service_tasks")
|
|
271
270
|
|
|
272
271
|
@should_scale_down_non_service_tasks.setter
|
|
273
|
-
def should_scale_down_non_service_tasks(self, value: Optional[pulumi.Input[
|
|
272
|
+
def should_scale_down_non_service_tasks(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
274
273
|
pulumi.set(self, "should_scale_down_non_service_tasks", value)
|
|
275
274
|
|
|
276
275
|
|
|
277
276
|
if not MYPY:
|
|
278
277
|
class OceanAutoscalerDownArgsDict(TypedDict):
|
|
279
|
-
max_scale_down_percentage: NotRequired[pulumi.Input[
|
|
278
|
+
max_scale_down_percentage: NotRequired[pulumi.Input[_builtins.float]]
|
|
280
279
|
"""
|
|
281
280
|
Would represent the maximum % to scale-down. Number between 1-100.
|
|
282
281
|
"""
|
|
@@ -286,37 +285,37 @@ elif False:
|
|
|
286
285
|
@pulumi.input_type
|
|
287
286
|
class OceanAutoscalerDownArgs:
|
|
288
287
|
def __init__(__self__, *,
|
|
289
|
-
max_scale_down_percentage: Optional[pulumi.Input[
|
|
288
|
+
max_scale_down_percentage: Optional[pulumi.Input[_builtins.float]] = None):
|
|
290
289
|
"""
|
|
291
|
-
:param pulumi.Input[
|
|
290
|
+
:param pulumi.Input[_builtins.float] max_scale_down_percentage: Would represent the maximum % to scale-down. Number between 1-100.
|
|
292
291
|
"""
|
|
293
292
|
if max_scale_down_percentage is not None:
|
|
294
293
|
pulumi.set(__self__, "max_scale_down_percentage", max_scale_down_percentage)
|
|
295
294
|
|
|
296
|
-
@property
|
|
295
|
+
@_builtins.property
|
|
297
296
|
@pulumi.getter(name="maxScaleDownPercentage")
|
|
298
|
-
def max_scale_down_percentage(self) -> Optional[pulumi.Input[
|
|
297
|
+
def max_scale_down_percentage(self) -> Optional[pulumi.Input[_builtins.float]]:
|
|
299
298
|
"""
|
|
300
299
|
Would represent the maximum % to scale-down. Number between 1-100.
|
|
301
300
|
"""
|
|
302
301
|
return pulumi.get(self, "max_scale_down_percentage")
|
|
303
302
|
|
|
304
303
|
@max_scale_down_percentage.setter
|
|
305
|
-
def max_scale_down_percentage(self, value: Optional[pulumi.Input[
|
|
304
|
+
def max_scale_down_percentage(self, value: Optional[pulumi.Input[_builtins.float]]):
|
|
306
305
|
pulumi.set(self, "max_scale_down_percentage", value)
|
|
307
306
|
|
|
308
307
|
|
|
309
308
|
if not MYPY:
|
|
310
309
|
class OceanAutoscalerHeadroomArgsDict(TypedDict):
|
|
311
|
-
cpu_per_unit: NotRequired[pulumi.Input[
|
|
310
|
+
cpu_per_unit: NotRequired[pulumi.Input[_builtins.int]]
|
|
312
311
|
"""
|
|
313
312
|
Optionally configure the number of CPUs to allocate the headroom. CPUs are denoted in millicores, where 1000 millicores = 1 vCPU.
|
|
314
313
|
"""
|
|
315
|
-
memory_per_unit: NotRequired[pulumi.Input[
|
|
314
|
+
memory_per_unit: NotRequired[pulumi.Input[_builtins.int]]
|
|
316
315
|
"""
|
|
317
316
|
Optionally configure the amount of memory (MB) to allocate the headroom.
|
|
318
317
|
"""
|
|
319
|
-
num_of_units: NotRequired[pulumi.Input[
|
|
318
|
+
num_of_units: NotRequired[pulumi.Input[_builtins.int]]
|
|
320
319
|
"""
|
|
321
320
|
The number of units to retain as headroom, where each unit has the defined headroom CPU and memory.
|
|
322
321
|
"""
|
|
@@ -326,13 +325,13 @@ elif False:
|
|
|
326
325
|
@pulumi.input_type
|
|
327
326
|
class OceanAutoscalerHeadroomArgs:
|
|
328
327
|
def __init__(__self__, *,
|
|
329
|
-
cpu_per_unit: Optional[pulumi.Input[
|
|
330
|
-
memory_per_unit: Optional[pulumi.Input[
|
|
331
|
-
num_of_units: Optional[pulumi.Input[
|
|
328
|
+
cpu_per_unit: Optional[pulumi.Input[_builtins.int]] = None,
|
|
329
|
+
memory_per_unit: Optional[pulumi.Input[_builtins.int]] = None,
|
|
330
|
+
num_of_units: Optional[pulumi.Input[_builtins.int]] = None):
|
|
332
331
|
"""
|
|
333
|
-
:param pulumi.Input[
|
|
334
|
-
:param pulumi.Input[
|
|
335
|
-
:param pulumi.Input[
|
|
332
|
+
: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.
|
|
333
|
+
:param pulumi.Input[_builtins.int] memory_per_unit: Optionally configure the amount of memory (MB) to allocate the headroom.
|
|
334
|
+
: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.
|
|
336
335
|
"""
|
|
337
336
|
if cpu_per_unit is not None:
|
|
338
337
|
pulumi.set(__self__, "cpu_per_unit", cpu_per_unit)
|
|
@@ -341,50 +340,50 @@ class OceanAutoscalerHeadroomArgs:
|
|
|
341
340
|
if num_of_units is not None:
|
|
342
341
|
pulumi.set(__self__, "num_of_units", num_of_units)
|
|
343
342
|
|
|
344
|
-
@property
|
|
343
|
+
@_builtins.property
|
|
345
344
|
@pulumi.getter(name="cpuPerUnit")
|
|
346
|
-
def cpu_per_unit(self) -> Optional[pulumi.Input[
|
|
345
|
+
def cpu_per_unit(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
347
346
|
"""
|
|
348
347
|
Optionally configure the number of CPUs to allocate the headroom. CPUs are denoted in millicores, where 1000 millicores = 1 vCPU.
|
|
349
348
|
"""
|
|
350
349
|
return pulumi.get(self, "cpu_per_unit")
|
|
351
350
|
|
|
352
351
|
@cpu_per_unit.setter
|
|
353
|
-
def cpu_per_unit(self, value: Optional[pulumi.Input[
|
|
352
|
+
def cpu_per_unit(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
354
353
|
pulumi.set(self, "cpu_per_unit", value)
|
|
355
354
|
|
|
356
|
-
@property
|
|
355
|
+
@_builtins.property
|
|
357
356
|
@pulumi.getter(name="memoryPerUnit")
|
|
358
|
-
def memory_per_unit(self) -> Optional[pulumi.Input[
|
|
357
|
+
def memory_per_unit(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
359
358
|
"""
|
|
360
359
|
Optionally configure the amount of memory (MB) to allocate the headroom.
|
|
361
360
|
"""
|
|
362
361
|
return pulumi.get(self, "memory_per_unit")
|
|
363
362
|
|
|
364
363
|
@memory_per_unit.setter
|
|
365
|
-
def memory_per_unit(self, value: Optional[pulumi.Input[
|
|
364
|
+
def memory_per_unit(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
366
365
|
pulumi.set(self, "memory_per_unit", value)
|
|
367
366
|
|
|
368
|
-
@property
|
|
367
|
+
@_builtins.property
|
|
369
368
|
@pulumi.getter(name="numOfUnits")
|
|
370
|
-
def num_of_units(self) -> Optional[pulumi.Input[
|
|
369
|
+
def num_of_units(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
371
370
|
"""
|
|
372
371
|
The number of units to retain as headroom, where each unit has the defined headroom CPU and memory.
|
|
373
372
|
"""
|
|
374
373
|
return pulumi.get(self, "num_of_units")
|
|
375
374
|
|
|
376
375
|
@num_of_units.setter
|
|
377
|
-
def num_of_units(self, value: Optional[pulumi.Input[
|
|
376
|
+
def num_of_units(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
378
377
|
pulumi.set(self, "num_of_units", value)
|
|
379
378
|
|
|
380
379
|
|
|
381
380
|
if not MYPY:
|
|
382
381
|
class OceanAutoscalerResourceLimitsArgsDict(TypedDict):
|
|
383
|
-
max_memory_gib: NotRequired[pulumi.Input[
|
|
382
|
+
max_memory_gib: NotRequired[pulumi.Input[_builtins.int]]
|
|
384
383
|
"""
|
|
385
384
|
The maximum memory in GiB units that can be allocated to the cluster.
|
|
386
385
|
"""
|
|
387
|
-
max_vcpu: NotRequired[pulumi.Input[
|
|
386
|
+
max_vcpu: NotRequired[pulumi.Input[_builtins.int]]
|
|
388
387
|
"""
|
|
389
388
|
The maximum cpu in vCPU units that can be allocated to the cluster.
|
|
390
389
|
"""
|
|
@@ -394,45 +393,45 @@ elif False:
|
|
|
394
393
|
@pulumi.input_type
|
|
395
394
|
class OceanAutoscalerResourceLimitsArgs:
|
|
396
395
|
def __init__(__self__, *,
|
|
397
|
-
max_memory_gib: Optional[pulumi.Input[
|
|
398
|
-
max_vcpu: Optional[pulumi.Input[
|
|
396
|
+
max_memory_gib: Optional[pulumi.Input[_builtins.int]] = None,
|
|
397
|
+
max_vcpu: Optional[pulumi.Input[_builtins.int]] = None):
|
|
399
398
|
"""
|
|
400
|
-
:param pulumi.Input[
|
|
401
|
-
:param pulumi.Input[
|
|
399
|
+
:param pulumi.Input[_builtins.int] max_memory_gib: The maximum memory in GiB units that can be allocated to the cluster.
|
|
400
|
+
:param pulumi.Input[_builtins.int] max_vcpu: The maximum cpu in vCPU units that can be allocated to the cluster.
|
|
402
401
|
"""
|
|
403
402
|
if max_memory_gib is not None:
|
|
404
403
|
pulumi.set(__self__, "max_memory_gib", max_memory_gib)
|
|
405
404
|
if max_vcpu is not None:
|
|
406
405
|
pulumi.set(__self__, "max_vcpu", max_vcpu)
|
|
407
406
|
|
|
408
|
-
@property
|
|
407
|
+
@_builtins.property
|
|
409
408
|
@pulumi.getter(name="maxMemoryGib")
|
|
410
|
-
def max_memory_gib(self) -> Optional[pulumi.Input[
|
|
409
|
+
def max_memory_gib(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
411
410
|
"""
|
|
412
411
|
The maximum memory in GiB units that can be allocated to the cluster.
|
|
413
412
|
"""
|
|
414
413
|
return pulumi.get(self, "max_memory_gib")
|
|
415
414
|
|
|
416
415
|
@max_memory_gib.setter
|
|
417
|
-
def max_memory_gib(self, value: Optional[pulumi.Input[
|
|
416
|
+
def max_memory_gib(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
418
417
|
pulumi.set(self, "max_memory_gib", value)
|
|
419
418
|
|
|
420
|
-
@property
|
|
419
|
+
@_builtins.property
|
|
421
420
|
@pulumi.getter(name="maxVcpu")
|
|
422
|
-
def max_vcpu(self) -> Optional[pulumi.Input[
|
|
421
|
+
def max_vcpu(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
423
422
|
"""
|
|
424
423
|
The maximum cpu in vCPU units that can be allocated to the cluster.
|
|
425
424
|
"""
|
|
426
425
|
return pulumi.get(self, "max_vcpu")
|
|
427
426
|
|
|
428
427
|
@max_vcpu.setter
|
|
429
|
-
def max_vcpu(self, value: Optional[pulumi.Input[
|
|
428
|
+
def max_vcpu(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
430
429
|
pulumi.set(self, "max_vcpu", value)
|
|
431
430
|
|
|
432
431
|
|
|
433
432
|
if not MYPY:
|
|
434
433
|
class OceanBlockDeviceMappingArgsDict(TypedDict):
|
|
435
|
-
device_name: pulumi.Input[
|
|
434
|
+
device_name: pulumi.Input[_builtins.str]
|
|
436
435
|
"""
|
|
437
436
|
String. Set device name. Example: `/dev/xvda1`.
|
|
438
437
|
"""
|
|
@@ -440,25 +439,25 @@ if not MYPY:
|
|
|
440
439
|
"""
|
|
441
440
|
Object. Set Elastic Block Store properties.
|
|
442
441
|
"""
|
|
443
|
-
no_device: NotRequired[pulumi.Input[
|
|
442
|
+
no_device: NotRequired[pulumi.Input[_builtins.str]]
|
|
444
443
|
"""
|
|
445
444
|
String. Suppresses the specified device included in the block device mapping of the AMI.
|
|
446
445
|
"""
|
|
447
|
-
virtual_name: NotRequired[pulumi.Input[
|
|
446
|
+
virtual_name: NotRequired[pulumi.Input[_builtins.str]]
|
|
448
447
|
elif False:
|
|
449
448
|
OceanBlockDeviceMappingArgsDict: TypeAlias = Mapping[str, Any]
|
|
450
449
|
|
|
451
450
|
@pulumi.input_type
|
|
452
451
|
class OceanBlockDeviceMappingArgs:
|
|
453
452
|
def __init__(__self__, *,
|
|
454
|
-
device_name: pulumi.Input[
|
|
453
|
+
device_name: pulumi.Input[_builtins.str],
|
|
455
454
|
ebs: Optional[pulumi.Input['OceanBlockDeviceMappingEbsArgs']] = None,
|
|
456
|
-
no_device: Optional[pulumi.Input[
|
|
457
|
-
virtual_name: Optional[pulumi.Input[
|
|
455
|
+
no_device: Optional[pulumi.Input[_builtins.str]] = None,
|
|
456
|
+
virtual_name: Optional[pulumi.Input[_builtins.str]] = None):
|
|
458
457
|
"""
|
|
459
|
-
:param pulumi.Input[
|
|
458
|
+
:param pulumi.Input[_builtins.str] device_name: String. Set device name. Example: `/dev/xvda1`.
|
|
460
459
|
:param pulumi.Input['OceanBlockDeviceMappingEbsArgs'] ebs: Object. Set Elastic Block Store properties.
|
|
461
|
-
:param pulumi.Input[
|
|
460
|
+
:param pulumi.Input[_builtins.str] no_device: String. Suppresses the specified device included in the block device mapping of the AMI.
|
|
462
461
|
"""
|
|
463
462
|
pulumi.set(__self__, "device_name", device_name)
|
|
464
463
|
if ebs is not None:
|
|
@@ -468,19 +467,19 @@ class OceanBlockDeviceMappingArgs:
|
|
|
468
467
|
if virtual_name is not None:
|
|
469
468
|
pulumi.set(__self__, "virtual_name", virtual_name)
|
|
470
469
|
|
|
471
|
-
@property
|
|
470
|
+
@_builtins.property
|
|
472
471
|
@pulumi.getter(name="deviceName")
|
|
473
|
-
def device_name(self) -> pulumi.Input[
|
|
472
|
+
def device_name(self) -> pulumi.Input[_builtins.str]:
|
|
474
473
|
"""
|
|
475
474
|
String. Set device name. Example: `/dev/xvda1`.
|
|
476
475
|
"""
|
|
477
476
|
return pulumi.get(self, "device_name")
|
|
478
477
|
|
|
479
478
|
@device_name.setter
|
|
480
|
-
def device_name(self, value: pulumi.Input[
|
|
479
|
+
def device_name(self, value: pulumi.Input[_builtins.str]):
|
|
481
480
|
pulumi.set(self, "device_name", value)
|
|
482
481
|
|
|
483
|
-
@property
|
|
482
|
+
@_builtins.property
|
|
484
483
|
@pulumi.getter
|
|
485
484
|
def ebs(self) -> Optional[pulumi.Input['OceanBlockDeviceMappingEbsArgs']]:
|
|
486
485
|
"""
|
|
@@ -492,31 +491,31 @@ class OceanBlockDeviceMappingArgs:
|
|
|
492
491
|
def ebs(self, value: Optional[pulumi.Input['OceanBlockDeviceMappingEbsArgs']]):
|
|
493
492
|
pulumi.set(self, "ebs", value)
|
|
494
493
|
|
|
495
|
-
@property
|
|
494
|
+
@_builtins.property
|
|
496
495
|
@pulumi.getter(name="noDevice")
|
|
497
|
-
def no_device(self) -> Optional[pulumi.Input[
|
|
496
|
+
def no_device(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
498
497
|
"""
|
|
499
498
|
String. Suppresses the specified device included in the block device mapping of the AMI.
|
|
500
499
|
"""
|
|
501
500
|
return pulumi.get(self, "no_device")
|
|
502
501
|
|
|
503
502
|
@no_device.setter
|
|
504
|
-
def no_device(self, value: Optional[pulumi.Input[
|
|
503
|
+
def no_device(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
505
504
|
pulumi.set(self, "no_device", value)
|
|
506
505
|
|
|
507
|
-
@property
|
|
506
|
+
@_builtins.property
|
|
508
507
|
@pulumi.getter(name="virtualName")
|
|
509
|
-
def virtual_name(self) -> Optional[pulumi.Input[
|
|
508
|
+
def virtual_name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
510
509
|
return pulumi.get(self, "virtual_name")
|
|
511
510
|
|
|
512
511
|
@virtual_name.setter
|
|
513
|
-
def virtual_name(self, value: Optional[pulumi.Input[
|
|
512
|
+
def virtual_name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
514
513
|
pulumi.set(self, "virtual_name", value)
|
|
515
514
|
|
|
516
515
|
|
|
517
516
|
if not MYPY:
|
|
518
517
|
class OceanBlockDeviceMappingEbsArgsDict(TypedDict):
|
|
519
|
-
delete_on_termination: NotRequired[pulumi.Input[
|
|
518
|
+
delete_on_termination: NotRequired[pulumi.Input[_builtins.bool]]
|
|
520
519
|
"""
|
|
521
520
|
Boolean. Toggles EBS deletion upon instance termination.
|
|
522
521
|
"""
|
|
@@ -524,31 +523,31 @@ if not MYPY:
|
|
|
524
523
|
"""
|
|
525
524
|
Object. Set dynamic volume size properties. When using this object, you cannot use volumeSize. You must use one or the other.
|
|
526
525
|
"""
|
|
527
|
-
encrypted: NotRequired[pulumi.Input[
|
|
526
|
+
encrypted: NotRequired[pulumi.Input[_builtins.bool]]
|
|
528
527
|
"""
|
|
529
528
|
Boolean. Enables [EBS encryption](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html) on the volume.
|
|
530
529
|
"""
|
|
531
|
-
iops: NotRequired[pulumi.Input[
|
|
530
|
+
iops: NotRequired[pulumi.Input[_builtins.int]]
|
|
532
531
|
"""
|
|
533
532
|
Int. The number of I/O operations per second (IOPS) that the volume supports.
|
|
534
533
|
"""
|
|
535
|
-
kms_key_id: NotRequired[pulumi.Input[
|
|
534
|
+
kms_key_id: NotRequired[pulumi.Input[_builtins.str]]
|
|
536
535
|
"""
|
|
537
536
|
String. Identifier (key ID, key alias, ID ARN, or alias ARN) for a customer managed CMK under which the EBS volume is encrypted.
|
|
538
537
|
"""
|
|
539
|
-
snapshot_id: NotRequired[pulumi.Input[
|
|
538
|
+
snapshot_id: NotRequired[pulumi.Input[_builtins.str]]
|
|
540
539
|
"""
|
|
541
540
|
(Optional) String. The snapshot ID to mount by.
|
|
542
541
|
"""
|
|
543
|
-
throughput: NotRequired[pulumi.Input[
|
|
542
|
+
throughput: NotRequired[pulumi.Input[_builtins.int]]
|
|
544
543
|
"""
|
|
545
544
|
The amount of data transferred to or from a storage device per second, you can use this param just in a case that `volume_type` = gp3.
|
|
546
545
|
"""
|
|
547
|
-
volume_size: NotRequired[pulumi.Input[
|
|
546
|
+
volume_size: NotRequired[pulumi.Input[_builtins.int]]
|
|
548
547
|
"""
|
|
549
548
|
Int. The size (in GB) of the volume.
|
|
550
549
|
"""
|
|
551
|
-
volume_type: NotRequired[pulumi.Input[
|
|
550
|
+
volume_type: NotRequired[pulumi.Input[_builtins.str]]
|
|
552
551
|
"""
|
|
553
552
|
String. The type of the volume. Example: `gp2`.
|
|
554
553
|
"""
|
|
@@ -558,25 +557,25 @@ elif False:
|
|
|
558
557
|
@pulumi.input_type
|
|
559
558
|
class OceanBlockDeviceMappingEbsArgs:
|
|
560
559
|
def __init__(__self__, *,
|
|
561
|
-
delete_on_termination: Optional[pulumi.Input[
|
|
560
|
+
delete_on_termination: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
562
561
|
dynamic_volume_size: Optional[pulumi.Input['OceanBlockDeviceMappingEbsDynamicVolumeSizeArgs']] = None,
|
|
563
|
-
encrypted: Optional[pulumi.Input[
|
|
564
|
-
iops: Optional[pulumi.Input[
|
|
565
|
-
kms_key_id: Optional[pulumi.Input[
|
|
566
|
-
snapshot_id: Optional[pulumi.Input[
|
|
567
|
-
throughput: Optional[pulumi.Input[
|
|
568
|
-
volume_size: Optional[pulumi.Input[
|
|
569
|
-
volume_type: Optional[pulumi.Input[
|
|
570
|
-
"""
|
|
571
|
-
:param pulumi.Input[
|
|
562
|
+
encrypted: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
563
|
+
iops: Optional[pulumi.Input[_builtins.int]] = None,
|
|
564
|
+
kms_key_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
565
|
+
snapshot_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
566
|
+
throughput: Optional[pulumi.Input[_builtins.int]] = None,
|
|
567
|
+
volume_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
568
|
+
volume_type: Optional[pulumi.Input[_builtins.str]] = None):
|
|
569
|
+
"""
|
|
570
|
+
:param pulumi.Input[_builtins.bool] delete_on_termination: Boolean. Toggles EBS deletion upon instance termination.
|
|
572
571
|
:param pulumi.Input['OceanBlockDeviceMappingEbsDynamicVolumeSizeArgs'] dynamic_volume_size: Object. Set dynamic volume size properties. When using this object, you cannot use volumeSize. You must use one or the other.
|
|
573
|
-
:param pulumi.Input[
|
|
574
|
-
:param pulumi.Input[
|
|
575
|
-
:param pulumi.Input[
|
|
576
|
-
:param pulumi.Input[
|
|
577
|
-
:param pulumi.Input[
|
|
578
|
-
:param pulumi.Input[
|
|
579
|
-
:param pulumi.Input[
|
|
572
|
+
:param pulumi.Input[_builtins.bool] encrypted: Boolean. Enables [EBS encryption](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html) on the volume.
|
|
573
|
+
:param pulumi.Input[_builtins.int] iops: Int. The number of I/O operations per second (IOPS) that the volume supports.
|
|
574
|
+
:param pulumi.Input[_builtins.str] kms_key_id: String. Identifier (key ID, key alias, ID ARN, or alias ARN) for a customer managed CMK under which the EBS volume is encrypted.
|
|
575
|
+
:param pulumi.Input[_builtins.str] snapshot_id: (Optional) String. The snapshot ID to mount by.
|
|
576
|
+
:param pulumi.Input[_builtins.int] throughput: The amount of data transferred to or from a storage device per second, you can use this param just in a case that `volume_type` = gp3.
|
|
577
|
+
:param pulumi.Input[_builtins.int] volume_size: Int. The size (in GB) of the volume.
|
|
578
|
+
:param pulumi.Input[_builtins.str] volume_type: String. The type of the volume. Example: `gp2`.
|
|
580
579
|
"""
|
|
581
580
|
if delete_on_termination is not None:
|
|
582
581
|
pulumi.set(__self__, "delete_on_termination", delete_on_termination)
|
|
@@ -597,19 +596,19 @@ class OceanBlockDeviceMappingEbsArgs:
|
|
|
597
596
|
if volume_type is not None:
|
|
598
597
|
pulumi.set(__self__, "volume_type", volume_type)
|
|
599
598
|
|
|
600
|
-
@property
|
|
599
|
+
@_builtins.property
|
|
601
600
|
@pulumi.getter(name="deleteOnTermination")
|
|
602
|
-
def delete_on_termination(self) -> Optional[pulumi.Input[
|
|
601
|
+
def delete_on_termination(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
603
602
|
"""
|
|
604
603
|
Boolean. Toggles EBS deletion upon instance termination.
|
|
605
604
|
"""
|
|
606
605
|
return pulumi.get(self, "delete_on_termination")
|
|
607
606
|
|
|
608
607
|
@delete_on_termination.setter
|
|
609
|
-
def delete_on_termination(self, value: Optional[pulumi.Input[
|
|
608
|
+
def delete_on_termination(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
610
609
|
pulumi.set(self, "delete_on_termination", value)
|
|
611
610
|
|
|
612
|
-
@property
|
|
611
|
+
@_builtins.property
|
|
613
612
|
@pulumi.getter(name="dynamicVolumeSize")
|
|
614
613
|
def dynamic_volume_size(self) -> Optional[pulumi.Input['OceanBlockDeviceMappingEbsDynamicVolumeSizeArgs']]:
|
|
615
614
|
"""
|
|
@@ -621,102 +620,102 @@ class OceanBlockDeviceMappingEbsArgs:
|
|
|
621
620
|
def dynamic_volume_size(self, value: Optional[pulumi.Input['OceanBlockDeviceMappingEbsDynamicVolumeSizeArgs']]):
|
|
622
621
|
pulumi.set(self, "dynamic_volume_size", value)
|
|
623
622
|
|
|
624
|
-
@property
|
|
623
|
+
@_builtins.property
|
|
625
624
|
@pulumi.getter
|
|
626
|
-
def encrypted(self) -> Optional[pulumi.Input[
|
|
625
|
+
def encrypted(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
627
626
|
"""
|
|
628
627
|
Boolean. Enables [EBS encryption](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html) on the volume.
|
|
629
628
|
"""
|
|
630
629
|
return pulumi.get(self, "encrypted")
|
|
631
630
|
|
|
632
631
|
@encrypted.setter
|
|
633
|
-
def encrypted(self, value: Optional[pulumi.Input[
|
|
632
|
+
def encrypted(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
634
633
|
pulumi.set(self, "encrypted", value)
|
|
635
634
|
|
|
636
|
-
@property
|
|
635
|
+
@_builtins.property
|
|
637
636
|
@pulumi.getter
|
|
638
|
-
def iops(self) -> Optional[pulumi.Input[
|
|
637
|
+
def iops(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
639
638
|
"""
|
|
640
639
|
Int. The number of I/O operations per second (IOPS) that the volume supports.
|
|
641
640
|
"""
|
|
642
641
|
return pulumi.get(self, "iops")
|
|
643
642
|
|
|
644
643
|
@iops.setter
|
|
645
|
-
def iops(self, value: Optional[pulumi.Input[
|
|
644
|
+
def iops(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
646
645
|
pulumi.set(self, "iops", value)
|
|
647
646
|
|
|
648
|
-
@property
|
|
647
|
+
@_builtins.property
|
|
649
648
|
@pulumi.getter(name="kmsKeyId")
|
|
650
|
-
def kms_key_id(self) -> Optional[pulumi.Input[
|
|
649
|
+
def kms_key_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
651
650
|
"""
|
|
652
651
|
String. Identifier (key ID, key alias, ID ARN, or alias ARN) for a customer managed CMK under which the EBS volume is encrypted.
|
|
653
652
|
"""
|
|
654
653
|
return pulumi.get(self, "kms_key_id")
|
|
655
654
|
|
|
656
655
|
@kms_key_id.setter
|
|
657
|
-
def kms_key_id(self, value: Optional[pulumi.Input[
|
|
656
|
+
def kms_key_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
658
657
|
pulumi.set(self, "kms_key_id", value)
|
|
659
658
|
|
|
660
|
-
@property
|
|
659
|
+
@_builtins.property
|
|
661
660
|
@pulumi.getter(name="snapshotId")
|
|
662
|
-
def snapshot_id(self) -> Optional[pulumi.Input[
|
|
661
|
+
def snapshot_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
663
662
|
"""
|
|
664
663
|
(Optional) String. The snapshot ID to mount by.
|
|
665
664
|
"""
|
|
666
665
|
return pulumi.get(self, "snapshot_id")
|
|
667
666
|
|
|
668
667
|
@snapshot_id.setter
|
|
669
|
-
def snapshot_id(self, value: Optional[pulumi.Input[
|
|
668
|
+
def snapshot_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
670
669
|
pulumi.set(self, "snapshot_id", value)
|
|
671
670
|
|
|
672
|
-
@property
|
|
671
|
+
@_builtins.property
|
|
673
672
|
@pulumi.getter
|
|
674
|
-
def throughput(self) -> Optional[pulumi.Input[
|
|
673
|
+
def throughput(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
675
674
|
"""
|
|
676
675
|
The amount of data transferred to or from a storage device per second, you can use this param just in a case that `volume_type` = gp3.
|
|
677
676
|
"""
|
|
678
677
|
return pulumi.get(self, "throughput")
|
|
679
678
|
|
|
680
679
|
@throughput.setter
|
|
681
|
-
def throughput(self, value: Optional[pulumi.Input[
|
|
680
|
+
def throughput(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
682
681
|
pulumi.set(self, "throughput", value)
|
|
683
682
|
|
|
684
|
-
@property
|
|
683
|
+
@_builtins.property
|
|
685
684
|
@pulumi.getter(name="volumeSize")
|
|
686
|
-
def volume_size(self) -> Optional[pulumi.Input[
|
|
685
|
+
def volume_size(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
687
686
|
"""
|
|
688
687
|
Int. The size (in GB) of the volume.
|
|
689
688
|
"""
|
|
690
689
|
return pulumi.get(self, "volume_size")
|
|
691
690
|
|
|
692
691
|
@volume_size.setter
|
|
693
|
-
def volume_size(self, value: Optional[pulumi.Input[
|
|
692
|
+
def volume_size(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
694
693
|
pulumi.set(self, "volume_size", value)
|
|
695
694
|
|
|
696
|
-
@property
|
|
695
|
+
@_builtins.property
|
|
697
696
|
@pulumi.getter(name="volumeType")
|
|
698
|
-
def volume_type(self) -> Optional[pulumi.Input[
|
|
697
|
+
def volume_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
699
698
|
"""
|
|
700
699
|
String. The type of the volume. Example: `gp2`.
|
|
701
700
|
"""
|
|
702
701
|
return pulumi.get(self, "volume_type")
|
|
703
702
|
|
|
704
703
|
@volume_type.setter
|
|
705
|
-
def volume_type(self, value: Optional[pulumi.Input[
|
|
704
|
+
def volume_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
706
705
|
pulumi.set(self, "volume_type", value)
|
|
707
706
|
|
|
708
707
|
|
|
709
708
|
if not MYPY:
|
|
710
709
|
class OceanBlockDeviceMappingEbsDynamicVolumeSizeArgsDict(TypedDict):
|
|
711
|
-
base_size: pulumi.Input[
|
|
710
|
+
base_size: pulumi.Input[_builtins.int]
|
|
712
711
|
"""
|
|
713
712
|
Int. Initial size for volume. Example: `50`.
|
|
714
713
|
"""
|
|
715
|
-
resource: pulumi.Input[
|
|
714
|
+
resource: pulumi.Input[_builtins.str]
|
|
716
715
|
"""
|
|
717
716
|
String. Resource type to increase volume size dynamically by. Valid values: `CPU`.
|
|
718
717
|
"""
|
|
719
|
-
size_per_resource_unit: pulumi.Input[
|
|
718
|
+
size_per_resource_unit: pulumi.Input[_builtins.int]
|
|
720
719
|
"""
|
|
721
720
|
Int. Additional size (in GB) per resource unit. Example: When the `baseSize=50`, `sizePerResourceUnit=20`, and instance with two CPUs is launched, its total disk size will be: 90GB.
|
|
722
721
|
"""
|
|
@@ -726,58 +725,58 @@ elif False:
|
|
|
726
725
|
@pulumi.input_type
|
|
727
726
|
class OceanBlockDeviceMappingEbsDynamicVolumeSizeArgs:
|
|
728
727
|
def __init__(__self__, *,
|
|
729
|
-
base_size: pulumi.Input[
|
|
730
|
-
resource: pulumi.Input[
|
|
731
|
-
size_per_resource_unit: pulumi.Input[
|
|
728
|
+
base_size: pulumi.Input[_builtins.int],
|
|
729
|
+
resource: pulumi.Input[_builtins.str],
|
|
730
|
+
size_per_resource_unit: pulumi.Input[_builtins.int]):
|
|
732
731
|
"""
|
|
733
|
-
:param pulumi.Input[
|
|
734
|
-
:param pulumi.Input[
|
|
735
|
-
:param pulumi.Input[
|
|
732
|
+
:param pulumi.Input[_builtins.int] base_size: Int. Initial size for volume. Example: `50`.
|
|
733
|
+
:param pulumi.Input[_builtins.str] resource: String. Resource type to increase volume size dynamically by. Valid values: `CPU`.
|
|
734
|
+
:param pulumi.Input[_builtins.int] size_per_resource_unit: Int. Additional size (in GB) per resource unit. Example: When the `baseSize=50`, `sizePerResourceUnit=20`, and instance with two CPUs is launched, its total disk size will be: 90GB.
|
|
736
735
|
"""
|
|
737
736
|
pulumi.set(__self__, "base_size", base_size)
|
|
738
737
|
pulumi.set(__self__, "resource", resource)
|
|
739
738
|
pulumi.set(__self__, "size_per_resource_unit", size_per_resource_unit)
|
|
740
739
|
|
|
741
|
-
@property
|
|
740
|
+
@_builtins.property
|
|
742
741
|
@pulumi.getter(name="baseSize")
|
|
743
|
-
def base_size(self) -> pulumi.Input[
|
|
742
|
+
def base_size(self) -> pulumi.Input[_builtins.int]:
|
|
744
743
|
"""
|
|
745
744
|
Int. Initial size for volume. Example: `50`.
|
|
746
745
|
"""
|
|
747
746
|
return pulumi.get(self, "base_size")
|
|
748
747
|
|
|
749
748
|
@base_size.setter
|
|
750
|
-
def base_size(self, value: pulumi.Input[
|
|
749
|
+
def base_size(self, value: pulumi.Input[_builtins.int]):
|
|
751
750
|
pulumi.set(self, "base_size", value)
|
|
752
751
|
|
|
753
|
-
@property
|
|
752
|
+
@_builtins.property
|
|
754
753
|
@pulumi.getter
|
|
755
|
-
def resource(self) -> pulumi.Input[
|
|
754
|
+
def resource(self) -> pulumi.Input[_builtins.str]:
|
|
756
755
|
"""
|
|
757
756
|
String. Resource type to increase volume size dynamically by. Valid values: `CPU`.
|
|
758
757
|
"""
|
|
759
758
|
return pulumi.get(self, "resource")
|
|
760
759
|
|
|
761
760
|
@resource.setter
|
|
762
|
-
def resource(self, value: pulumi.Input[
|
|
761
|
+
def resource(self, value: pulumi.Input[_builtins.str]):
|
|
763
762
|
pulumi.set(self, "resource", value)
|
|
764
763
|
|
|
765
|
-
@property
|
|
764
|
+
@_builtins.property
|
|
766
765
|
@pulumi.getter(name="sizePerResourceUnit")
|
|
767
|
-
def size_per_resource_unit(self) -> pulumi.Input[
|
|
766
|
+
def size_per_resource_unit(self) -> pulumi.Input[_builtins.int]:
|
|
768
767
|
"""
|
|
769
768
|
Int. Additional size (in GB) per resource unit. Example: When the `baseSize=50`, `sizePerResourceUnit=20`, and instance with two CPUs is launched, its total disk size will be: 90GB.
|
|
770
769
|
"""
|
|
771
770
|
return pulumi.get(self, "size_per_resource_unit")
|
|
772
771
|
|
|
773
772
|
@size_per_resource_unit.setter
|
|
774
|
-
def size_per_resource_unit(self, value: pulumi.Input[
|
|
773
|
+
def size_per_resource_unit(self, value: pulumi.Input[_builtins.int]):
|
|
775
774
|
pulumi.set(self, "size_per_resource_unit", value)
|
|
776
775
|
|
|
777
776
|
|
|
778
777
|
if not MYPY:
|
|
779
778
|
class OceanClusterOrientationArgsDict(TypedDict):
|
|
780
|
-
availability_vs_cost: NotRequired[pulumi.Input[
|
|
779
|
+
availability_vs_cost: NotRequired[pulumi.Input[_builtins.str]]
|
|
781
780
|
"""
|
|
782
781
|
You can control the approach that Ocean takes while launching nodes by configuring this value. Possible values: `costOriented`,`balanced`,`cheapest`.
|
|
783
782
|
"""
|
|
@@ -787,95 +786,95 @@ elif False:
|
|
|
787
786
|
@pulumi.input_type
|
|
788
787
|
class OceanClusterOrientationArgs:
|
|
789
788
|
def __init__(__self__, *,
|
|
790
|
-
availability_vs_cost: Optional[pulumi.Input[
|
|
789
|
+
availability_vs_cost: Optional[pulumi.Input[_builtins.str]] = None):
|
|
791
790
|
"""
|
|
792
|
-
:param pulumi.Input[
|
|
791
|
+
:param pulumi.Input[_builtins.str] availability_vs_cost: You can control the approach that Ocean takes while launching nodes by configuring this value. Possible values: `costOriented`,`balanced`,`cheapest`.
|
|
793
792
|
"""
|
|
794
793
|
if availability_vs_cost is not None:
|
|
795
794
|
pulumi.set(__self__, "availability_vs_cost", availability_vs_cost)
|
|
796
795
|
|
|
797
|
-
@property
|
|
796
|
+
@_builtins.property
|
|
798
797
|
@pulumi.getter(name="availabilityVsCost")
|
|
799
|
-
def availability_vs_cost(self) -> Optional[pulumi.Input[
|
|
798
|
+
def availability_vs_cost(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
800
799
|
"""
|
|
801
800
|
You can control the approach that Ocean takes while launching nodes by configuring this value. Possible values: `costOriented`,`balanced`,`cheapest`.
|
|
802
801
|
"""
|
|
803
802
|
return pulumi.get(self, "availability_vs_cost")
|
|
804
803
|
|
|
805
804
|
@availability_vs_cost.setter
|
|
806
|
-
def availability_vs_cost(self, value: Optional[pulumi.Input[
|
|
805
|
+
def availability_vs_cost(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
807
806
|
pulumi.set(self, "availability_vs_cost", value)
|
|
808
807
|
|
|
809
808
|
|
|
810
809
|
if not MYPY:
|
|
811
810
|
class OceanFiltersArgsDict(TypedDict):
|
|
812
|
-
architectures: NotRequired[pulumi.Input[Sequence[pulumi.Input[
|
|
811
|
+
architectures: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
813
812
|
"""
|
|
814
813
|
The filtered instance types will support at least one of the architectures from this list.
|
|
815
814
|
"""
|
|
816
|
-
categories: NotRequired[pulumi.Input[Sequence[pulumi.Input[
|
|
815
|
+
categories: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
817
816
|
"""
|
|
818
817
|
The filtered instance types will belong to one of the categories types from this list.
|
|
819
818
|
"""
|
|
820
|
-
disk_types: NotRequired[pulumi.Input[Sequence[pulumi.Input[
|
|
819
|
+
disk_types: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
821
820
|
"""
|
|
822
821
|
The filtered instance types will have one of the disk type from this list.
|
|
823
822
|
"""
|
|
824
|
-
exclude_families: NotRequired[pulumi.Input[Sequence[pulumi.Input[
|
|
823
|
+
exclude_families: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
825
824
|
"""
|
|
826
825
|
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.
|
|
827
826
|
"""
|
|
828
|
-
exclude_metal: NotRequired[pulumi.Input[
|
|
827
|
+
exclude_metal: NotRequired[pulumi.Input[_builtins.bool]]
|
|
829
828
|
"""
|
|
830
829
|
In case excludeMetal is set to true, metal types will not be available for scaling.
|
|
831
830
|
"""
|
|
832
|
-
hypervisors: NotRequired[pulumi.Input[Sequence[pulumi.Input[
|
|
831
|
+
hypervisors: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
833
832
|
"""
|
|
834
833
|
The filtered instance types will have a hypervisor type from this list.
|
|
835
834
|
"""
|
|
836
|
-
include_families: NotRequired[pulumi.Input[Sequence[pulumi.Input[
|
|
835
|
+
include_families: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
837
836
|
"""
|
|
838
837
|
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.
|
|
839
838
|
"""
|
|
840
|
-
is_ena_supported: NotRequired[pulumi.Input[
|
|
839
|
+
is_ena_supported: NotRequired[pulumi.Input[_builtins.str]]
|
|
841
840
|
"""
|
|
842
841
|
Ena is supported or not.
|
|
843
842
|
"""
|
|
844
|
-
max_gpu: NotRequired[pulumi.Input[
|
|
843
|
+
max_gpu: NotRequired[pulumi.Input[_builtins.int]]
|
|
845
844
|
"""
|
|
846
845
|
Maximum total number of GPUs.
|
|
847
846
|
"""
|
|
848
|
-
max_memory_gib: NotRequired[pulumi.Input[
|
|
849
|
-
max_network_performance: NotRequired[pulumi.Input[
|
|
847
|
+
max_memory_gib: NotRequired[pulumi.Input[_builtins.float]]
|
|
848
|
+
max_network_performance: NotRequired[pulumi.Input[_builtins.int]]
|
|
850
849
|
"""
|
|
851
850
|
Maximum Bandwidth in Gib/s of network performance.
|
|
852
851
|
"""
|
|
853
|
-
max_vcpu: NotRequired[pulumi.Input[
|
|
854
|
-
min_enis: NotRequired[pulumi.Input[
|
|
852
|
+
max_vcpu: NotRequired[pulumi.Input[_builtins.int]]
|
|
853
|
+
min_enis: NotRequired[pulumi.Input[_builtins.int]]
|
|
855
854
|
"""
|
|
856
855
|
Minimum number of network interfaces (ENIs).
|
|
857
856
|
"""
|
|
858
|
-
min_gpu: NotRequired[pulumi.Input[
|
|
857
|
+
min_gpu: NotRequired[pulumi.Input[_builtins.int]]
|
|
859
858
|
"""
|
|
860
859
|
Minimum total number of GPUs.
|
|
861
860
|
"""
|
|
862
|
-
min_memory_gib: NotRequired[pulumi.Input[
|
|
861
|
+
min_memory_gib: NotRequired[pulumi.Input[_builtins.float]]
|
|
863
862
|
"""
|
|
864
863
|
Minimum amount of Memory (GiB).
|
|
865
864
|
"""
|
|
866
|
-
min_network_performance: NotRequired[pulumi.Input[
|
|
865
|
+
min_network_performance: NotRequired[pulumi.Input[_builtins.int]]
|
|
867
866
|
"""
|
|
868
867
|
Minimum Bandwidth in Gib/s of network performance.
|
|
869
868
|
"""
|
|
870
|
-
min_vcpu: NotRequired[pulumi.Input[
|
|
869
|
+
min_vcpu: NotRequired[pulumi.Input[_builtins.int]]
|
|
871
870
|
"""
|
|
872
871
|
Minimum number of vcpus available.
|
|
873
872
|
"""
|
|
874
|
-
root_device_types: NotRequired[pulumi.Input[Sequence[pulumi.Input[
|
|
873
|
+
root_device_types: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
875
874
|
"""
|
|
876
875
|
The filtered instance types will have a root device types from this list.
|
|
877
876
|
"""
|
|
878
|
-
virtualization_types: NotRequired[pulumi.Input[Sequence[pulumi.Input[
|
|
877
|
+
virtualization_types: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
879
878
|
"""
|
|
880
879
|
The filtered instance types will support at least one of the virtualization types from this list.
|
|
881
880
|
"""
|
|
@@ -885,43 +884,43 @@ elif False:
|
|
|
885
884
|
@pulumi.input_type
|
|
886
885
|
class OceanFiltersArgs:
|
|
887
886
|
def __init__(__self__, *,
|
|
888
|
-
architectures: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
889
|
-
categories: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
890
|
-
disk_types: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
891
|
-
exclude_families: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
892
|
-
exclude_metal: Optional[pulumi.Input[
|
|
893
|
-
hypervisors: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
894
|
-
include_families: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
895
|
-
is_ena_supported: Optional[pulumi.Input[
|
|
896
|
-
max_gpu: Optional[pulumi.Input[
|
|
897
|
-
max_memory_gib: Optional[pulumi.Input[
|
|
898
|
-
max_network_performance: Optional[pulumi.Input[
|
|
899
|
-
max_vcpu: Optional[pulumi.Input[
|
|
900
|
-
min_enis: Optional[pulumi.Input[
|
|
901
|
-
min_gpu: Optional[pulumi.Input[
|
|
902
|
-
min_memory_gib: Optional[pulumi.Input[
|
|
903
|
-
min_network_performance: Optional[pulumi.Input[
|
|
904
|
-
min_vcpu: Optional[pulumi.Input[
|
|
905
|
-
root_device_types: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
906
|
-
virtualization_types: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
907
|
-
"""
|
|
908
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
909
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
910
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
911
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
912
|
-
:param pulumi.Input[
|
|
913
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
914
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
915
|
-
:param pulumi.Input[
|
|
916
|
-
:param pulumi.Input[
|
|
917
|
-
:param pulumi.Input[
|
|
918
|
-
:param pulumi.Input[
|
|
919
|
-
:param pulumi.Input[
|
|
920
|
-
:param pulumi.Input[
|
|
921
|
-
:param pulumi.Input[
|
|
922
|
-
:param pulumi.Input[
|
|
923
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
924
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
887
|
+
architectures: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
888
|
+
categories: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
889
|
+
disk_types: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
890
|
+
exclude_families: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
891
|
+
exclude_metal: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
892
|
+
hypervisors: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
893
|
+
include_families: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
894
|
+
is_ena_supported: Optional[pulumi.Input[_builtins.str]] = None,
|
|
895
|
+
max_gpu: Optional[pulumi.Input[_builtins.int]] = None,
|
|
896
|
+
max_memory_gib: Optional[pulumi.Input[_builtins.float]] = None,
|
|
897
|
+
max_network_performance: Optional[pulumi.Input[_builtins.int]] = None,
|
|
898
|
+
max_vcpu: Optional[pulumi.Input[_builtins.int]] = None,
|
|
899
|
+
min_enis: Optional[pulumi.Input[_builtins.int]] = None,
|
|
900
|
+
min_gpu: Optional[pulumi.Input[_builtins.int]] = None,
|
|
901
|
+
min_memory_gib: Optional[pulumi.Input[_builtins.float]] = None,
|
|
902
|
+
min_network_performance: Optional[pulumi.Input[_builtins.int]] = None,
|
|
903
|
+
min_vcpu: Optional[pulumi.Input[_builtins.int]] = None,
|
|
904
|
+
root_device_types: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
905
|
+
virtualization_types: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
|
|
906
|
+
"""
|
|
907
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] architectures: The filtered instance types will support at least one of the architectures from this list.
|
|
908
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] categories: The filtered instance types will belong to one of the categories types from this list.
|
|
909
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] disk_types: The filtered instance types will have one of the disk type from this list.
|
|
910
|
+
: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.
|
|
911
|
+
:param pulumi.Input[_builtins.bool] exclude_metal: In case excludeMetal is set to true, metal types will not be available for scaling.
|
|
912
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] hypervisors: The filtered instance types will have a hypervisor type from this list.
|
|
913
|
+
: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.
|
|
914
|
+
:param pulumi.Input[_builtins.str] is_ena_supported: Ena is supported or not.
|
|
915
|
+
:param pulumi.Input[_builtins.int] max_gpu: Maximum total number of GPUs.
|
|
916
|
+
:param pulumi.Input[_builtins.int] max_network_performance: Maximum Bandwidth in Gib/s of network performance.
|
|
917
|
+
:param pulumi.Input[_builtins.int] min_enis: Minimum number of network interfaces (ENIs).
|
|
918
|
+
:param pulumi.Input[_builtins.int] min_gpu: Minimum total number of GPUs.
|
|
919
|
+
:param pulumi.Input[_builtins.float] min_memory_gib: Minimum amount of Memory (GiB).
|
|
920
|
+
:param pulumi.Input[_builtins.int] min_network_performance: Minimum Bandwidth in Gib/s of network performance.
|
|
921
|
+
:param pulumi.Input[_builtins.int] min_vcpu: Minimum number of vcpus available.
|
|
922
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] root_device_types: The filtered instance types will have a root device types from this list.
|
|
923
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] virtualization_types: The filtered instance types will support at least one of the virtualization types from this list.
|
|
925
924
|
"""
|
|
926
925
|
if architectures is not None:
|
|
927
926
|
pulumi.set(__self__, "architectures", architectures)
|
|
@@ -962,236 +961,236 @@ class OceanFiltersArgs:
|
|
|
962
961
|
if virtualization_types is not None:
|
|
963
962
|
pulumi.set(__self__, "virtualization_types", virtualization_types)
|
|
964
963
|
|
|
965
|
-
@property
|
|
964
|
+
@_builtins.property
|
|
966
965
|
@pulumi.getter
|
|
967
|
-
def architectures(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
966
|
+
def architectures(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
968
967
|
"""
|
|
969
968
|
The filtered instance types will support at least one of the architectures from this list.
|
|
970
969
|
"""
|
|
971
970
|
return pulumi.get(self, "architectures")
|
|
972
971
|
|
|
973
972
|
@architectures.setter
|
|
974
|
-
def architectures(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
973
|
+
def architectures(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
975
974
|
pulumi.set(self, "architectures", value)
|
|
976
975
|
|
|
977
|
-
@property
|
|
976
|
+
@_builtins.property
|
|
978
977
|
@pulumi.getter
|
|
979
|
-
def categories(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
978
|
+
def categories(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
980
979
|
"""
|
|
981
980
|
The filtered instance types will belong to one of the categories types from this list.
|
|
982
981
|
"""
|
|
983
982
|
return pulumi.get(self, "categories")
|
|
984
983
|
|
|
985
984
|
@categories.setter
|
|
986
|
-
def categories(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
985
|
+
def categories(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
987
986
|
pulumi.set(self, "categories", value)
|
|
988
987
|
|
|
989
|
-
@property
|
|
988
|
+
@_builtins.property
|
|
990
989
|
@pulumi.getter(name="diskTypes")
|
|
991
|
-
def disk_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
990
|
+
def disk_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
992
991
|
"""
|
|
993
992
|
The filtered instance types will have one of the disk type from this list.
|
|
994
993
|
"""
|
|
995
994
|
return pulumi.get(self, "disk_types")
|
|
996
995
|
|
|
997
996
|
@disk_types.setter
|
|
998
|
-
def disk_types(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
997
|
+
def disk_types(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
999
998
|
pulumi.set(self, "disk_types", value)
|
|
1000
999
|
|
|
1001
|
-
@property
|
|
1000
|
+
@_builtins.property
|
|
1002
1001
|
@pulumi.getter(name="excludeFamilies")
|
|
1003
|
-
def exclude_families(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1002
|
+
def exclude_families(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
1004
1003
|
"""
|
|
1005
1004
|
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.
|
|
1006
1005
|
"""
|
|
1007
1006
|
return pulumi.get(self, "exclude_families")
|
|
1008
1007
|
|
|
1009
1008
|
@exclude_families.setter
|
|
1010
|
-
def exclude_families(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1009
|
+
def exclude_families(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
1011
1010
|
pulumi.set(self, "exclude_families", value)
|
|
1012
1011
|
|
|
1013
|
-
@property
|
|
1012
|
+
@_builtins.property
|
|
1014
1013
|
@pulumi.getter(name="excludeMetal")
|
|
1015
|
-
def exclude_metal(self) -> Optional[pulumi.Input[
|
|
1014
|
+
def exclude_metal(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1016
1015
|
"""
|
|
1017
1016
|
In case excludeMetal is set to true, metal types will not be available for scaling.
|
|
1018
1017
|
"""
|
|
1019
1018
|
return pulumi.get(self, "exclude_metal")
|
|
1020
1019
|
|
|
1021
1020
|
@exclude_metal.setter
|
|
1022
|
-
def exclude_metal(self, value: Optional[pulumi.Input[
|
|
1021
|
+
def exclude_metal(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1023
1022
|
pulumi.set(self, "exclude_metal", value)
|
|
1024
1023
|
|
|
1025
|
-
@property
|
|
1024
|
+
@_builtins.property
|
|
1026
1025
|
@pulumi.getter
|
|
1027
|
-
def hypervisors(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1026
|
+
def hypervisors(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
1028
1027
|
"""
|
|
1029
1028
|
The filtered instance types will have a hypervisor type from this list.
|
|
1030
1029
|
"""
|
|
1031
1030
|
return pulumi.get(self, "hypervisors")
|
|
1032
1031
|
|
|
1033
1032
|
@hypervisors.setter
|
|
1034
|
-
def hypervisors(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1033
|
+
def hypervisors(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
1035
1034
|
pulumi.set(self, "hypervisors", value)
|
|
1036
1035
|
|
|
1037
|
-
@property
|
|
1036
|
+
@_builtins.property
|
|
1038
1037
|
@pulumi.getter(name="includeFamilies")
|
|
1039
|
-
def include_families(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1038
|
+
def include_families(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
1040
1039
|
"""
|
|
1041
1040
|
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.
|
|
1042
1041
|
"""
|
|
1043
1042
|
return pulumi.get(self, "include_families")
|
|
1044
1043
|
|
|
1045
1044
|
@include_families.setter
|
|
1046
|
-
def include_families(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1045
|
+
def include_families(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
1047
1046
|
pulumi.set(self, "include_families", value)
|
|
1048
1047
|
|
|
1049
|
-
@property
|
|
1048
|
+
@_builtins.property
|
|
1050
1049
|
@pulumi.getter(name="isEnaSupported")
|
|
1051
|
-
def is_ena_supported(self) -> Optional[pulumi.Input[
|
|
1050
|
+
def is_ena_supported(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1052
1051
|
"""
|
|
1053
1052
|
Ena is supported or not.
|
|
1054
1053
|
"""
|
|
1055
1054
|
return pulumi.get(self, "is_ena_supported")
|
|
1056
1055
|
|
|
1057
1056
|
@is_ena_supported.setter
|
|
1058
|
-
def is_ena_supported(self, value: Optional[pulumi.Input[
|
|
1057
|
+
def is_ena_supported(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1059
1058
|
pulumi.set(self, "is_ena_supported", value)
|
|
1060
1059
|
|
|
1061
|
-
@property
|
|
1060
|
+
@_builtins.property
|
|
1062
1061
|
@pulumi.getter(name="maxGpu")
|
|
1063
|
-
def max_gpu(self) -> Optional[pulumi.Input[
|
|
1062
|
+
def max_gpu(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1064
1063
|
"""
|
|
1065
1064
|
Maximum total number of GPUs.
|
|
1066
1065
|
"""
|
|
1067
1066
|
return pulumi.get(self, "max_gpu")
|
|
1068
1067
|
|
|
1069
1068
|
@max_gpu.setter
|
|
1070
|
-
def max_gpu(self, value: Optional[pulumi.Input[
|
|
1069
|
+
def max_gpu(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1071
1070
|
pulumi.set(self, "max_gpu", value)
|
|
1072
1071
|
|
|
1073
|
-
@property
|
|
1072
|
+
@_builtins.property
|
|
1074
1073
|
@pulumi.getter(name="maxMemoryGib")
|
|
1075
|
-
def max_memory_gib(self) -> Optional[pulumi.Input[
|
|
1074
|
+
def max_memory_gib(self) -> Optional[pulumi.Input[_builtins.float]]:
|
|
1076
1075
|
return pulumi.get(self, "max_memory_gib")
|
|
1077
1076
|
|
|
1078
1077
|
@max_memory_gib.setter
|
|
1079
|
-
def max_memory_gib(self, value: Optional[pulumi.Input[
|
|
1078
|
+
def max_memory_gib(self, value: Optional[pulumi.Input[_builtins.float]]):
|
|
1080
1079
|
pulumi.set(self, "max_memory_gib", value)
|
|
1081
1080
|
|
|
1082
|
-
@property
|
|
1081
|
+
@_builtins.property
|
|
1083
1082
|
@pulumi.getter(name="maxNetworkPerformance")
|
|
1084
|
-
def max_network_performance(self) -> Optional[pulumi.Input[
|
|
1083
|
+
def max_network_performance(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1085
1084
|
"""
|
|
1086
1085
|
Maximum Bandwidth in Gib/s of network performance.
|
|
1087
1086
|
"""
|
|
1088
1087
|
return pulumi.get(self, "max_network_performance")
|
|
1089
1088
|
|
|
1090
1089
|
@max_network_performance.setter
|
|
1091
|
-
def max_network_performance(self, value: Optional[pulumi.Input[
|
|
1090
|
+
def max_network_performance(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1092
1091
|
pulumi.set(self, "max_network_performance", value)
|
|
1093
1092
|
|
|
1094
|
-
@property
|
|
1093
|
+
@_builtins.property
|
|
1095
1094
|
@pulumi.getter(name="maxVcpu")
|
|
1096
|
-
def max_vcpu(self) -> Optional[pulumi.Input[
|
|
1095
|
+
def max_vcpu(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1097
1096
|
return pulumi.get(self, "max_vcpu")
|
|
1098
1097
|
|
|
1099
1098
|
@max_vcpu.setter
|
|
1100
|
-
def max_vcpu(self, value: Optional[pulumi.Input[
|
|
1099
|
+
def max_vcpu(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1101
1100
|
pulumi.set(self, "max_vcpu", value)
|
|
1102
1101
|
|
|
1103
|
-
@property
|
|
1102
|
+
@_builtins.property
|
|
1104
1103
|
@pulumi.getter(name="minEnis")
|
|
1105
|
-
def min_enis(self) -> Optional[pulumi.Input[
|
|
1104
|
+
def min_enis(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1106
1105
|
"""
|
|
1107
1106
|
Minimum number of network interfaces (ENIs).
|
|
1108
1107
|
"""
|
|
1109
1108
|
return pulumi.get(self, "min_enis")
|
|
1110
1109
|
|
|
1111
1110
|
@min_enis.setter
|
|
1112
|
-
def min_enis(self, value: Optional[pulumi.Input[
|
|
1111
|
+
def min_enis(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1113
1112
|
pulumi.set(self, "min_enis", value)
|
|
1114
1113
|
|
|
1115
|
-
@property
|
|
1114
|
+
@_builtins.property
|
|
1116
1115
|
@pulumi.getter(name="minGpu")
|
|
1117
|
-
def min_gpu(self) -> Optional[pulumi.Input[
|
|
1116
|
+
def min_gpu(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1118
1117
|
"""
|
|
1119
1118
|
Minimum total number of GPUs.
|
|
1120
1119
|
"""
|
|
1121
1120
|
return pulumi.get(self, "min_gpu")
|
|
1122
1121
|
|
|
1123
1122
|
@min_gpu.setter
|
|
1124
|
-
def min_gpu(self, value: Optional[pulumi.Input[
|
|
1123
|
+
def min_gpu(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1125
1124
|
pulumi.set(self, "min_gpu", value)
|
|
1126
1125
|
|
|
1127
|
-
@property
|
|
1126
|
+
@_builtins.property
|
|
1128
1127
|
@pulumi.getter(name="minMemoryGib")
|
|
1129
|
-
def min_memory_gib(self) -> Optional[pulumi.Input[
|
|
1128
|
+
def min_memory_gib(self) -> Optional[pulumi.Input[_builtins.float]]:
|
|
1130
1129
|
"""
|
|
1131
1130
|
Minimum amount of Memory (GiB).
|
|
1132
1131
|
"""
|
|
1133
1132
|
return pulumi.get(self, "min_memory_gib")
|
|
1134
1133
|
|
|
1135
1134
|
@min_memory_gib.setter
|
|
1136
|
-
def min_memory_gib(self, value: Optional[pulumi.Input[
|
|
1135
|
+
def min_memory_gib(self, value: Optional[pulumi.Input[_builtins.float]]):
|
|
1137
1136
|
pulumi.set(self, "min_memory_gib", value)
|
|
1138
1137
|
|
|
1139
|
-
@property
|
|
1138
|
+
@_builtins.property
|
|
1140
1139
|
@pulumi.getter(name="minNetworkPerformance")
|
|
1141
|
-
def min_network_performance(self) -> Optional[pulumi.Input[
|
|
1140
|
+
def min_network_performance(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1142
1141
|
"""
|
|
1143
1142
|
Minimum Bandwidth in Gib/s of network performance.
|
|
1144
1143
|
"""
|
|
1145
1144
|
return pulumi.get(self, "min_network_performance")
|
|
1146
1145
|
|
|
1147
1146
|
@min_network_performance.setter
|
|
1148
|
-
def min_network_performance(self, value: Optional[pulumi.Input[
|
|
1147
|
+
def min_network_performance(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1149
1148
|
pulumi.set(self, "min_network_performance", value)
|
|
1150
1149
|
|
|
1151
|
-
@property
|
|
1150
|
+
@_builtins.property
|
|
1152
1151
|
@pulumi.getter(name="minVcpu")
|
|
1153
|
-
def min_vcpu(self) -> Optional[pulumi.Input[
|
|
1152
|
+
def min_vcpu(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1154
1153
|
"""
|
|
1155
1154
|
Minimum number of vcpus available.
|
|
1156
1155
|
"""
|
|
1157
1156
|
return pulumi.get(self, "min_vcpu")
|
|
1158
1157
|
|
|
1159
1158
|
@min_vcpu.setter
|
|
1160
|
-
def min_vcpu(self, value: Optional[pulumi.Input[
|
|
1159
|
+
def min_vcpu(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1161
1160
|
pulumi.set(self, "min_vcpu", value)
|
|
1162
1161
|
|
|
1163
|
-
@property
|
|
1162
|
+
@_builtins.property
|
|
1164
1163
|
@pulumi.getter(name="rootDeviceTypes")
|
|
1165
|
-
def root_device_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1164
|
+
def root_device_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
1166
1165
|
"""
|
|
1167
1166
|
The filtered instance types will have a root device types from this list.
|
|
1168
1167
|
"""
|
|
1169
1168
|
return pulumi.get(self, "root_device_types")
|
|
1170
1169
|
|
|
1171
1170
|
@root_device_types.setter
|
|
1172
|
-
def root_device_types(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1171
|
+
def root_device_types(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
1173
1172
|
pulumi.set(self, "root_device_types", value)
|
|
1174
1173
|
|
|
1175
|
-
@property
|
|
1174
|
+
@_builtins.property
|
|
1176
1175
|
@pulumi.getter(name="virtualizationTypes")
|
|
1177
|
-
def virtualization_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1176
|
+
def virtualization_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
1178
1177
|
"""
|
|
1179
1178
|
The filtered instance types will support at least one of the virtualization types from this list.
|
|
1180
1179
|
"""
|
|
1181
1180
|
return pulumi.get(self, "virtualization_types")
|
|
1182
1181
|
|
|
1183
1182
|
@virtualization_types.setter
|
|
1184
|
-
def virtualization_types(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1183
|
+
def virtualization_types(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
1185
1184
|
pulumi.set(self, "virtualization_types", value)
|
|
1186
1185
|
|
|
1187
1186
|
|
|
1188
1187
|
if not MYPY:
|
|
1189
1188
|
class OceanInstanceMetadataOptionsArgsDict(TypedDict):
|
|
1190
|
-
http_tokens: pulumi.Input[
|
|
1189
|
+
http_tokens: pulumi.Input[_builtins.str]
|
|
1191
1190
|
"""
|
|
1192
1191
|
Determines if a signed token is required or not. Valid values: `optional` or `required`.
|
|
1193
1192
|
"""
|
|
1194
|
-
http_put_response_hop_limit: NotRequired[pulumi.Input[
|
|
1193
|
+
http_put_response_hop_limit: NotRequired[pulumi.Input[_builtins.int]]
|
|
1195
1194
|
"""
|
|
1196
1195
|
An integer from 1 through 64. The desired HTTP PUT response hop limit for instance metadata requests. The larger the number, the further the instance metadata requests can travel.
|
|
1197
1196
|
"""
|
|
@@ -1201,48 +1200,48 @@ elif False:
|
|
|
1201
1200
|
@pulumi.input_type
|
|
1202
1201
|
class OceanInstanceMetadataOptionsArgs:
|
|
1203
1202
|
def __init__(__self__, *,
|
|
1204
|
-
http_tokens: pulumi.Input[
|
|
1205
|
-
http_put_response_hop_limit: Optional[pulumi.Input[
|
|
1203
|
+
http_tokens: pulumi.Input[_builtins.str],
|
|
1204
|
+
http_put_response_hop_limit: Optional[pulumi.Input[_builtins.int]] = None):
|
|
1206
1205
|
"""
|
|
1207
|
-
:param pulumi.Input[
|
|
1208
|
-
:param pulumi.Input[
|
|
1206
|
+
:param pulumi.Input[_builtins.str] http_tokens: Determines if a signed token is required or not. Valid values: `optional` or `required`.
|
|
1207
|
+
:param pulumi.Input[_builtins.int] http_put_response_hop_limit: An integer from 1 through 64. The desired HTTP PUT response hop limit for instance metadata requests. The larger the number, the further the instance metadata requests can travel.
|
|
1209
1208
|
"""
|
|
1210
1209
|
pulumi.set(__self__, "http_tokens", http_tokens)
|
|
1211
1210
|
if http_put_response_hop_limit is not None:
|
|
1212
1211
|
pulumi.set(__self__, "http_put_response_hop_limit", http_put_response_hop_limit)
|
|
1213
1212
|
|
|
1214
|
-
@property
|
|
1213
|
+
@_builtins.property
|
|
1215
1214
|
@pulumi.getter(name="httpTokens")
|
|
1216
|
-
def http_tokens(self) -> pulumi.Input[
|
|
1215
|
+
def http_tokens(self) -> pulumi.Input[_builtins.str]:
|
|
1217
1216
|
"""
|
|
1218
1217
|
Determines if a signed token is required or not. Valid values: `optional` or `required`.
|
|
1219
1218
|
"""
|
|
1220
1219
|
return pulumi.get(self, "http_tokens")
|
|
1221
1220
|
|
|
1222
1221
|
@http_tokens.setter
|
|
1223
|
-
def http_tokens(self, value: pulumi.Input[
|
|
1222
|
+
def http_tokens(self, value: pulumi.Input[_builtins.str]):
|
|
1224
1223
|
pulumi.set(self, "http_tokens", value)
|
|
1225
1224
|
|
|
1226
|
-
@property
|
|
1225
|
+
@_builtins.property
|
|
1227
1226
|
@pulumi.getter(name="httpPutResponseHopLimit")
|
|
1228
|
-
def http_put_response_hop_limit(self) -> Optional[pulumi.Input[
|
|
1227
|
+
def http_put_response_hop_limit(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1229
1228
|
"""
|
|
1230
1229
|
An integer from 1 through 64. The desired HTTP PUT response hop limit for instance metadata requests. The larger the number, the further the instance metadata requests can travel.
|
|
1231
1230
|
"""
|
|
1232
1231
|
return pulumi.get(self, "http_put_response_hop_limit")
|
|
1233
1232
|
|
|
1234
1233
|
@http_put_response_hop_limit.setter
|
|
1235
|
-
def http_put_response_hop_limit(self, value: Optional[pulumi.Input[
|
|
1234
|
+
def http_put_response_hop_limit(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1236
1235
|
pulumi.set(self, "http_put_response_hop_limit", value)
|
|
1237
1236
|
|
|
1238
1237
|
|
|
1239
1238
|
if not MYPY:
|
|
1240
1239
|
class OceanLaunchSpecAttributeArgsDict(TypedDict):
|
|
1241
|
-
key: pulumi.Input[
|
|
1240
|
+
key: pulumi.Input[_builtins.str]
|
|
1242
1241
|
"""
|
|
1243
1242
|
The label key.
|
|
1244
1243
|
"""
|
|
1245
|
-
value: pulumi.Input[
|
|
1244
|
+
value: pulumi.Input[_builtins.str]
|
|
1246
1245
|
"""
|
|
1247
1246
|
The label value.
|
|
1248
1247
|
"""
|
|
@@ -1252,51 +1251,51 @@ elif False:
|
|
|
1252
1251
|
@pulumi.input_type
|
|
1253
1252
|
class OceanLaunchSpecAttributeArgs:
|
|
1254
1253
|
def __init__(__self__, *,
|
|
1255
|
-
key: pulumi.Input[
|
|
1256
|
-
value: pulumi.Input[
|
|
1254
|
+
key: pulumi.Input[_builtins.str],
|
|
1255
|
+
value: pulumi.Input[_builtins.str]):
|
|
1257
1256
|
"""
|
|
1258
|
-
:param pulumi.Input[
|
|
1259
|
-
:param pulumi.Input[
|
|
1257
|
+
:param pulumi.Input[_builtins.str] key: The label key.
|
|
1258
|
+
:param pulumi.Input[_builtins.str] value: The label value.
|
|
1260
1259
|
"""
|
|
1261
1260
|
pulumi.set(__self__, "key", key)
|
|
1262
1261
|
pulumi.set(__self__, "value", value)
|
|
1263
1262
|
|
|
1264
|
-
@property
|
|
1263
|
+
@_builtins.property
|
|
1265
1264
|
@pulumi.getter
|
|
1266
|
-
def key(self) -> pulumi.Input[
|
|
1265
|
+
def key(self) -> pulumi.Input[_builtins.str]:
|
|
1267
1266
|
"""
|
|
1268
1267
|
The label key.
|
|
1269
1268
|
"""
|
|
1270
1269
|
return pulumi.get(self, "key")
|
|
1271
1270
|
|
|
1272
1271
|
@key.setter
|
|
1273
|
-
def key(self, value: pulumi.Input[
|
|
1272
|
+
def key(self, value: pulumi.Input[_builtins.str]):
|
|
1274
1273
|
pulumi.set(self, "key", value)
|
|
1275
1274
|
|
|
1276
|
-
@property
|
|
1275
|
+
@_builtins.property
|
|
1277
1276
|
@pulumi.getter
|
|
1278
|
-
def value(self) -> pulumi.Input[
|
|
1277
|
+
def value(self) -> pulumi.Input[_builtins.str]:
|
|
1279
1278
|
"""
|
|
1280
1279
|
The label value.
|
|
1281
1280
|
"""
|
|
1282
1281
|
return pulumi.get(self, "value")
|
|
1283
1282
|
|
|
1284
1283
|
@value.setter
|
|
1285
|
-
def value(self, value: pulumi.Input[
|
|
1284
|
+
def value(self, value: pulumi.Input[_builtins.str]):
|
|
1286
1285
|
pulumi.set(self, "value", value)
|
|
1287
1286
|
|
|
1288
1287
|
|
|
1289
1288
|
if not MYPY:
|
|
1290
1289
|
class OceanLaunchSpecAutoscaleHeadroomArgsDict(TypedDict):
|
|
1291
|
-
num_of_units: pulumi.Input[
|
|
1290
|
+
num_of_units: pulumi.Input[_builtins.int]
|
|
1292
1291
|
"""
|
|
1293
1292
|
The number of units to retain as headroom, where each unit has the defined headroom CPU and memory.
|
|
1294
1293
|
"""
|
|
1295
|
-
cpu_per_unit: NotRequired[pulumi.Input[
|
|
1294
|
+
cpu_per_unit: NotRequired[pulumi.Input[_builtins.int]]
|
|
1296
1295
|
"""
|
|
1297
1296
|
Optionally configure the number of CPUs to allocate for each headroom unit. CPUs are denoted in CPU units, where 1024 units = 1 vCPU.
|
|
1298
1297
|
"""
|
|
1299
|
-
memory_per_unit: NotRequired[pulumi.Input[
|
|
1298
|
+
memory_per_unit: NotRequired[pulumi.Input[_builtins.int]]
|
|
1300
1299
|
"""
|
|
1301
1300
|
Optionally configure the amount of memory (MiB) to allocate for each headroom unit.
|
|
1302
1301
|
"""
|
|
@@ -1306,13 +1305,13 @@ elif False:
|
|
|
1306
1305
|
@pulumi.input_type
|
|
1307
1306
|
class OceanLaunchSpecAutoscaleHeadroomArgs:
|
|
1308
1307
|
def __init__(__self__, *,
|
|
1309
|
-
num_of_units: pulumi.Input[
|
|
1310
|
-
cpu_per_unit: Optional[pulumi.Input[
|
|
1311
|
-
memory_per_unit: Optional[pulumi.Input[
|
|
1308
|
+
num_of_units: pulumi.Input[_builtins.int],
|
|
1309
|
+
cpu_per_unit: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1310
|
+
memory_per_unit: Optional[pulumi.Input[_builtins.int]] = None):
|
|
1312
1311
|
"""
|
|
1313
|
-
:param pulumi.Input[
|
|
1314
|
-
:param pulumi.Input[
|
|
1315
|
-
:param pulumi.Input[
|
|
1312
|
+
: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.
|
|
1313
|
+
:param pulumi.Input[_builtins.int] cpu_per_unit: Optionally configure the number of CPUs to allocate for each headroom unit. CPUs are denoted in CPU units, where 1024 units = 1 vCPU.
|
|
1314
|
+
:param pulumi.Input[_builtins.int] memory_per_unit: Optionally configure the amount of memory (MiB) to allocate for each headroom unit.
|
|
1316
1315
|
"""
|
|
1317
1316
|
pulumi.set(__self__, "num_of_units", num_of_units)
|
|
1318
1317
|
if cpu_per_unit is not None:
|
|
@@ -1320,46 +1319,46 @@ class OceanLaunchSpecAutoscaleHeadroomArgs:
|
|
|
1320
1319
|
if memory_per_unit is not None:
|
|
1321
1320
|
pulumi.set(__self__, "memory_per_unit", memory_per_unit)
|
|
1322
1321
|
|
|
1323
|
-
@property
|
|
1322
|
+
@_builtins.property
|
|
1324
1323
|
@pulumi.getter(name="numOfUnits")
|
|
1325
|
-
def num_of_units(self) -> pulumi.Input[
|
|
1324
|
+
def num_of_units(self) -> pulumi.Input[_builtins.int]:
|
|
1326
1325
|
"""
|
|
1327
1326
|
The number of units to retain as headroom, where each unit has the defined headroom CPU and memory.
|
|
1328
1327
|
"""
|
|
1329
1328
|
return pulumi.get(self, "num_of_units")
|
|
1330
1329
|
|
|
1331
1330
|
@num_of_units.setter
|
|
1332
|
-
def num_of_units(self, value: pulumi.Input[
|
|
1331
|
+
def num_of_units(self, value: pulumi.Input[_builtins.int]):
|
|
1333
1332
|
pulumi.set(self, "num_of_units", value)
|
|
1334
1333
|
|
|
1335
|
-
@property
|
|
1334
|
+
@_builtins.property
|
|
1336
1335
|
@pulumi.getter(name="cpuPerUnit")
|
|
1337
|
-
def cpu_per_unit(self) -> Optional[pulumi.Input[
|
|
1336
|
+
def cpu_per_unit(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1338
1337
|
"""
|
|
1339
1338
|
Optionally configure the number of CPUs to allocate for each headroom unit. CPUs are denoted in CPU units, where 1024 units = 1 vCPU.
|
|
1340
1339
|
"""
|
|
1341
1340
|
return pulumi.get(self, "cpu_per_unit")
|
|
1342
1341
|
|
|
1343
1342
|
@cpu_per_unit.setter
|
|
1344
|
-
def cpu_per_unit(self, value: Optional[pulumi.Input[
|
|
1343
|
+
def cpu_per_unit(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1345
1344
|
pulumi.set(self, "cpu_per_unit", value)
|
|
1346
1345
|
|
|
1347
|
-
@property
|
|
1346
|
+
@_builtins.property
|
|
1348
1347
|
@pulumi.getter(name="memoryPerUnit")
|
|
1349
|
-
def memory_per_unit(self) -> Optional[pulumi.Input[
|
|
1348
|
+
def memory_per_unit(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1350
1349
|
"""
|
|
1351
1350
|
Optionally configure the amount of memory (MiB) to allocate for each headroom unit.
|
|
1352
1351
|
"""
|
|
1353
1352
|
return pulumi.get(self, "memory_per_unit")
|
|
1354
1353
|
|
|
1355
1354
|
@memory_per_unit.setter
|
|
1356
|
-
def memory_per_unit(self, value: Optional[pulumi.Input[
|
|
1355
|
+
def memory_per_unit(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1357
1356
|
pulumi.set(self, "memory_per_unit", value)
|
|
1358
1357
|
|
|
1359
1358
|
|
|
1360
1359
|
if not MYPY:
|
|
1361
1360
|
class OceanLaunchSpecBlockDeviceMappingArgsDict(TypedDict):
|
|
1362
|
-
device_name: pulumi.Input[
|
|
1361
|
+
device_name: pulumi.Input[_builtins.str]
|
|
1363
1362
|
"""
|
|
1364
1363
|
String. Set device name. (Example: "/dev/xvda1").
|
|
1365
1364
|
"""
|
|
@@ -1367,25 +1366,25 @@ if not MYPY:
|
|
|
1367
1366
|
"""
|
|
1368
1367
|
Object. Set Elastic Block Store properties .
|
|
1369
1368
|
"""
|
|
1370
|
-
no_device: NotRequired[pulumi.Input[
|
|
1369
|
+
no_device: NotRequired[pulumi.Input[_builtins.str]]
|
|
1371
1370
|
"""
|
|
1372
1371
|
String. suppresses the specified device included in the block device mapping of the AMI.
|
|
1373
1372
|
"""
|
|
1374
|
-
virtual_name: NotRequired[pulumi.Input[
|
|
1373
|
+
virtual_name: NotRequired[pulumi.Input[_builtins.str]]
|
|
1375
1374
|
elif False:
|
|
1376
1375
|
OceanLaunchSpecBlockDeviceMappingArgsDict: TypeAlias = Mapping[str, Any]
|
|
1377
1376
|
|
|
1378
1377
|
@pulumi.input_type
|
|
1379
1378
|
class OceanLaunchSpecBlockDeviceMappingArgs:
|
|
1380
1379
|
def __init__(__self__, *,
|
|
1381
|
-
device_name: pulumi.Input[
|
|
1380
|
+
device_name: pulumi.Input[_builtins.str],
|
|
1382
1381
|
ebs: Optional[pulumi.Input['OceanLaunchSpecBlockDeviceMappingEbsArgs']] = None,
|
|
1383
|
-
no_device: Optional[pulumi.Input[
|
|
1384
|
-
virtual_name: Optional[pulumi.Input[
|
|
1382
|
+
no_device: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1383
|
+
virtual_name: Optional[pulumi.Input[_builtins.str]] = None):
|
|
1385
1384
|
"""
|
|
1386
|
-
:param pulumi.Input[
|
|
1385
|
+
:param pulumi.Input[_builtins.str] device_name: String. Set device name. (Example: "/dev/xvda1").
|
|
1387
1386
|
:param pulumi.Input['OceanLaunchSpecBlockDeviceMappingEbsArgs'] ebs: Object. Set Elastic Block Store properties .
|
|
1388
|
-
:param pulumi.Input[
|
|
1387
|
+
:param pulumi.Input[_builtins.str] no_device: String. suppresses the specified device included in the block device mapping of the AMI.
|
|
1389
1388
|
"""
|
|
1390
1389
|
pulumi.set(__self__, "device_name", device_name)
|
|
1391
1390
|
if ebs is not None:
|
|
@@ -1395,19 +1394,19 @@ class OceanLaunchSpecBlockDeviceMappingArgs:
|
|
|
1395
1394
|
if virtual_name is not None:
|
|
1396
1395
|
pulumi.set(__self__, "virtual_name", virtual_name)
|
|
1397
1396
|
|
|
1398
|
-
@property
|
|
1397
|
+
@_builtins.property
|
|
1399
1398
|
@pulumi.getter(name="deviceName")
|
|
1400
|
-
def device_name(self) -> pulumi.Input[
|
|
1399
|
+
def device_name(self) -> pulumi.Input[_builtins.str]:
|
|
1401
1400
|
"""
|
|
1402
1401
|
String. Set device name. (Example: "/dev/xvda1").
|
|
1403
1402
|
"""
|
|
1404
1403
|
return pulumi.get(self, "device_name")
|
|
1405
1404
|
|
|
1406
1405
|
@device_name.setter
|
|
1407
|
-
def device_name(self, value: pulumi.Input[
|
|
1406
|
+
def device_name(self, value: pulumi.Input[_builtins.str]):
|
|
1408
1407
|
pulumi.set(self, "device_name", value)
|
|
1409
1408
|
|
|
1410
|
-
@property
|
|
1409
|
+
@_builtins.property
|
|
1411
1410
|
@pulumi.getter
|
|
1412
1411
|
def ebs(self) -> Optional[pulumi.Input['OceanLaunchSpecBlockDeviceMappingEbsArgs']]:
|
|
1413
1412
|
"""
|
|
@@ -1419,31 +1418,31 @@ class OceanLaunchSpecBlockDeviceMappingArgs:
|
|
|
1419
1418
|
def ebs(self, value: Optional[pulumi.Input['OceanLaunchSpecBlockDeviceMappingEbsArgs']]):
|
|
1420
1419
|
pulumi.set(self, "ebs", value)
|
|
1421
1420
|
|
|
1422
|
-
@property
|
|
1421
|
+
@_builtins.property
|
|
1423
1422
|
@pulumi.getter(name="noDevice")
|
|
1424
|
-
def no_device(self) -> Optional[pulumi.Input[
|
|
1423
|
+
def no_device(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1425
1424
|
"""
|
|
1426
1425
|
String. suppresses the specified device included in the block device mapping of the AMI.
|
|
1427
1426
|
"""
|
|
1428
1427
|
return pulumi.get(self, "no_device")
|
|
1429
1428
|
|
|
1430
1429
|
@no_device.setter
|
|
1431
|
-
def no_device(self, value: Optional[pulumi.Input[
|
|
1430
|
+
def no_device(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1432
1431
|
pulumi.set(self, "no_device", value)
|
|
1433
1432
|
|
|
1434
|
-
@property
|
|
1433
|
+
@_builtins.property
|
|
1435
1434
|
@pulumi.getter(name="virtualName")
|
|
1436
|
-
def virtual_name(self) -> Optional[pulumi.Input[
|
|
1435
|
+
def virtual_name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1437
1436
|
return pulumi.get(self, "virtual_name")
|
|
1438
1437
|
|
|
1439
1438
|
@virtual_name.setter
|
|
1440
|
-
def virtual_name(self, value: Optional[pulumi.Input[
|
|
1439
|
+
def virtual_name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1441
1440
|
pulumi.set(self, "virtual_name", value)
|
|
1442
1441
|
|
|
1443
1442
|
|
|
1444
1443
|
if not MYPY:
|
|
1445
1444
|
class OceanLaunchSpecBlockDeviceMappingEbsArgsDict(TypedDict):
|
|
1446
|
-
delete_on_termination: NotRequired[pulumi.Input[
|
|
1445
|
+
delete_on_termination: NotRequired[pulumi.Input[_builtins.bool]]
|
|
1447
1446
|
"""
|
|
1448
1447
|
Boolean. Flag to delete the EBS on instance termination.
|
|
1449
1448
|
"""
|
|
@@ -1451,31 +1450,31 @@ if not MYPY:
|
|
|
1451
1450
|
"""
|
|
1452
1451
|
Object. Set dynamic volume size properties. When using this object, you cannot use volumeSize. You must use one or the other.
|
|
1453
1452
|
"""
|
|
1454
|
-
encrypted: NotRequired[pulumi.Input[
|
|
1453
|
+
encrypted: NotRequired[pulumi.Input[_builtins.bool]]
|
|
1455
1454
|
"""
|
|
1456
1455
|
Boolean. Enables [EBS encryption](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html) on the volume.
|
|
1457
1456
|
"""
|
|
1458
|
-
iops: NotRequired[pulumi.Input[
|
|
1457
|
+
iops: NotRequired[pulumi.Input[_builtins.int]]
|
|
1459
1458
|
"""
|
|
1460
1459
|
Int. The number of I/O operations per second (IOPS) that the volume supports.
|
|
1461
1460
|
"""
|
|
1462
|
-
kms_key_id: NotRequired[pulumi.Input[
|
|
1461
|
+
kms_key_id: NotRequired[pulumi.Input[_builtins.str]]
|
|
1463
1462
|
"""
|
|
1464
1463
|
String. Identifier (key ID, key alias, ID ARN, or alias ARN) for a customer managed CMK under which the EBS volume is encrypted.
|
|
1465
1464
|
"""
|
|
1466
|
-
snapshot_id: NotRequired[pulumi.Input[
|
|
1465
|
+
snapshot_id: NotRequired[pulumi.Input[_builtins.str]]
|
|
1467
1466
|
"""
|
|
1468
1467
|
(Optional) String. The Snapshot ID to mount by.
|
|
1469
1468
|
"""
|
|
1470
|
-
throughput: NotRequired[pulumi.Input[
|
|
1469
|
+
throughput: NotRequired[pulumi.Input[_builtins.int]]
|
|
1471
1470
|
"""
|
|
1472
1471
|
The amount of data transferred to or from a storage device per second, you can use this param just in a case that `volume_type` = gp3.
|
|
1473
1472
|
"""
|
|
1474
|
-
volume_size: NotRequired[pulumi.Input[
|
|
1473
|
+
volume_size: NotRequired[pulumi.Input[_builtins.int]]
|
|
1475
1474
|
"""
|
|
1476
1475
|
Int. The size, in GB of the volume.
|
|
1477
1476
|
"""
|
|
1478
|
-
volume_type: NotRequired[pulumi.Input[
|
|
1477
|
+
volume_type: NotRequired[pulumi.Input[_builtins.str]]
|
|
1479
1478
|
"""
|
|
1480
1479
|
String. The type of the volume (example: "gp2").
|
|
1481
1480
|
"""
|
|
@@ -1485,25 +1484,25 @@ elif False:
|
|
|
1485
1484
|
@pulumi.input_type
|
|
1486
1485
|
class OceanLaunchSpecBlockDeviceMappingEbsArgs:
|
|
1487
1486
|
def __init__(__self__, *,
|
|
1488
|
-
delete_on_termination: Optional[pulumi.Input[
|
|
1487
|
+
delete_on_termination: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1489
1488
|
dynamic_volume_size: Optional[pulumi.Input['OceanLaunchSpecBlockDeviceMappingEbsDynamicVolumeSizeArgs']] = None,
|
|
1490
|
-
encrypted: Optional[pulumi.Input[
|
|
1491
|
-
iops: Optional[pulumi.Input[
|
|
1492
|
-
kms_key_id: Optional[pulumi.Input[
|
|
1493
|
-
snapshot_id: Optional[pulumi.Input[
|
|
1494
|
-
throughput: Optional[pulumi.Input[
|
|
1495
|
-
volume_size: Optional[pulumi.Input[
|
|
1496
|
-
volume_type: Optional[pulumi.Input[
|
|
1497
|
-
"""
|
|
1498
|
-
:param pulumi.Input[
|
|
1489
|
+
encrypted: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1490
|
+
iops: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1491
|
+
kms_key_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1492
|
+
snapshot_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1493
|
+
throughput: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1494
|
+
volume_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1495
|
+
volume_type: Optional[pulumi.Input[_builtins.str]] = None):
|
|
1496
|
+
"""
|
|
1497
|
+
:param pulumi.Input[_builtins.bool] delete_on_termination: Boolean. Flag to delete the EBS on instance termination.
|
|
1499
1498
|
:param pulumi.Input['OceanLaunchSpecBlockDeviceMappingEbsDynamicVolumeSizeArgs'] dynamic_volume_size: Object. Set dynamic volume size properties. When using this object, you cannot use volumeSize. You must use one or the other.
|
|
1500
|
-
:param pulumi.Input[
|
|
1501
|
-
:param pulumi.Input[
|
|
1502
|
-
:param pulumi.Input[
|
|
1503
|
-
:param pulumi.Input[
|
|
1504
|
-
:param pulumi.Input[
|
|
1505
|
-
:param pulumi.Input[
|
|
1506
|
-
:param pulumi.Input[
|
|
1499
|
+
:param pulumi.Input[_builtins.bool] encrypted: Boolean. Enables [EBS encryption](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html) on the volume.
|
|
1500
|
+
:param pulumi.Input[_builtins.int] iops: Int. The number of I/O operations per second (IOPS) that the volume supports.
|
|
1501
|
+
:param pulumi.Input[_builtins.str] kms_key_id: String. Identifier (key ID, key alias, ID ARN, or alias ARN) for a customer managed CMK under which the EBS volume is encrypted.
|
|
1502
|
+
:param pulumi.Input[_builtins.str] snapshot_id: (Optional) String. The Snapshot ID to mount by.
|
|
1503
|
+
:param pulumi.Input[_builtins.int] throughput: The amount of data transferred to or from a storage device per second, you can use this param just in a case that `volume_type` = gp3.
|
|
1504
|
+
:param pulumi.Input[_builtins.int] volume_size: Int. The size, in GB of the volume.
|
|
1505
|
+
:param pulumi.Input[_builtins.str] volume_type: String. The type of the volume (example: "gp2").
|
|
1507
1506
|
"""
|
|
1508
1507
|
if delete_on_termination is not None:
|
|
1509
1508
|
pulumi.set(__self__, "delete_on_termination", delete_on_termination)
|
|
@@ -1524,19 +1523,19 @@ class OceanLaunchSpecBlockDeviceMappingEbsArgs:
|
|
|
1524
1523
|
if volume_type is not None:
|
|
1525
1524
|
pulumi.set(__self__, "volume_type", volume_type)
|
|
1526
1525
|
|
|
1527
|
-
@property
|
|
1526
|
+
@_builtins.property
|
|
1528
1527
|
@pulumi.getter(name="deleteOnTermination")
|
|
1529
|
-
def delete_on_termination(self) -> Optional[pulumi.Input[
|
|
1528
|
+
def delete_on_termination(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1530
1529
|
"""
|
|
1531
1530
|
Boolean. Flag to delete the EBS on instance termination.
|
|
1532
1531
|
"""
|
|
1533
1532
|
return pulumi.get(self, "delete_on_termination")
|
|
1534
1533
|
|
|
1535
1534
|
@delete_on_termination.setter
|
|
1536
|
-
def delete_on_termination(self, value: Optional[pulumi.Input[
|
|
1535
|
+
def delete_on_termination(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1537
1536
|
pulumi.set(self, "delete_on_termination", value)
|
|
1538
1537
|
|
|
1539
|
-
@property
|
|
1538
|
+
@_builtins.property
|
|
1540
1539
|
@pulumi.getter(name="dynamicVolumeSize")
|
|
1541
1540
|
def dynamic_volume_size(self) -> Optional[pulumi.Input['OceanLaunchSpecBlockDeviceMappingEbsDynamicVolumeSizeArgs']]:
|
|
1542
1541
|
"""
|
|
@@ -1548,102 +1547,102 @@ class OceanLaunchSpecBlockDeviceMappingEbsArgs:
|
|
|
1548
1547
|
def dynamic_volume_size(self, value: Optional[pulumi.Input['OceanLaunchSpecBlockDeviceMappingEbsDynamicVolumeSizeArgs']]):
|
|
1549
1548
|
pulumi.set(self, "dynamic_volume_size", value)
|
|
1550
1549
|
|
|
1551
|
-
@property
|
|
1550
|
+
@_builtins.property
|
|
1552
1551
|
@pulumi.getter
|
|
1553
|
-
def encrypted(self) -> Optional[pulumi.Input[
|
|
1552
|
+
def encrypted(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1554
1553
|
"""
|
|
1555
1554
|
Boolean. Enables [EBS encryption](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html) on the volume.
|
|
1556
1555
|
"""
|
|
1557
1556
|
return pulumi.get(self, "encrypted")
|
|
1558
1557
|
|
|
1559
1558
|
@encrypted.setter
|
|
1560
|
-
def encrypted(self, value: Optional[pulumi.Input[
|
|
1559
|
+
def encrypted(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1561
1560
|
pulumi.set(self, "encrypted", value)
|
|
1562
1561
|
|
|
1563
|
-
@property
|
|
1562
|
+
@_builtins.property
|
|
1564
1563
|
@pulumi.getter
|
|
1565
|
-
def iops(self) -> Optional[pulumi.Input[
|
|
1564
|
+
def iops(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1566
1565
|
"""
|
|
1567
1566
|
Int. The number of I/O operations per second (IOPS) that the volume supports.
|
|
1568
1567
|
"""
|
|
1569
1568
|
return pulumi.get(self, "iops")
|
|
1570
1569
|
|
|
1571
1570
|
@iops.setter
|
|
1572
|
-
def iops(self, value: Optional[pulumi.Input[
|
|
1571
|
+
def iops(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1573
1572
|
pulumi.set(self, "iops", value)
|
|
1574
1573
|
|
|
1575
|
-
@property
|
|
1574
|
+
@_builtins.property
|
|
1576
1575
|
@pulumi.getter(name="kmsKeyId")
|
|
1577
|
-
def kms_key_id(self) -> Optional[pulumi.Input[
|
|
1576
|
+
def kms_key_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1578
1577
|
"""
|
|
1579
1578
|
String. Identifier (key ID, key alias, ID ARN, or alias ARN) for a customer managed CMK under which the EBS volume is encrypted.
|
|
1580
1579
|
"""
|
|
1581
1580
|
return pulumi.get(self, "kms_key_id")
|
|
1582
1581
|
|
|
1583
1582
|
@kms_key_id.setter
|
|
1584
|
-
def kms_key_id(self, value: Optional[pulumi.Input[
|
|
1583
|
+
def kms_key_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1585
1584
|
pulumi.set(self, "kms_key_id", value)
|
|
1586
1585
|
|
|
1587
|
-
@property
|
|
1586
|
+
@_builtins.property
|
|
1588
1587
|
@pulumi.getter(name="snapshotId")
|
|
1589
|
-
def snapshot_id(self) -> Optional[pulumi.Input[
|
|
1588
|
+
def snapshot_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1590
1589
|
"""
|
|
1591
1590
|
(Optional) String. The Snapshot ID to mount by.
|
|
1592
1591
|
"""
|
|
1593
1592
|
return pulumi.get(self, "snapshot_id")
|
|
1594
1593
|
|
|
1595
1594
|
@snapshot_id.setter
|
|
1596
|
-
def snapshot_id(self, value: Optional[pulumi.Input[
|
|
1595
|
+
def snapshot_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1597
1596
|
pulumi.set(self, "snapshot_id", value)
|
|
1598
1597
|
|
|
1599
|
-
@property
|
|
1598
|
+
@_builtins.property
|
|
1600
1599
|
@pulumi.getter
|
|
1601
|
-
def throughput(self) -> Optional[pulumi.Input[
|
|
1600
|
+
def throughput(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1602
1601
|
"""
|
|
1603
1602
|
The amount of data transferred to or from a storage device per second, you can use this param just in a case that `volume_type` = gp3.
|
|
1604
1603
|
"""
|
|
1605
1604
|
return pulumi.get(self, "throughput")
|
|
1606
1605
|
|
|
1607
1606
|
@throughput.setter
|
|
1608
|
-
def throughput(self, value: Optional[pulumi.Input[
|
|
1607
|
+
def throughput(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1609
1608
|
pulumi.set(self, "throughput", value)
|
|
1610
1609
|
|
|
1611
|
-
@property
|
|
1610
|
+
@_builtins.property
|
|
1612
1611
|
@pulumi.getter(name="volumeSize")
|
|
1613
|
-
def volume_size(self) -> Optional[pulumi.Input[
|
|
1612
|
+
def volume_size(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1614
1613
|
"""
|
|
1615
1614
|
Int. The size, in GB of the volume.
|
|
1616
1615
|
"""
|
|
1617
1616
|
return pulumi.get(self, "volume_size")
|
|
1618
1617
|
|
|
1619
1618
|
@volume_size.setter
|
|
1620
|
-
def volume_size(self, value: Optional[pulumi.Input[
|
|
1619
|
+
def volume_size(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1621
1620
|
pulumi.set(self, "volume_size", value)
|
|
1622
1621
|
|
|
1623
|
-
@property
|
|
1622
|
+
@_builtins.property
|
|
1624
1623
|
@pulumi.getter(name="volumeType")
|
|
1625
|
-
def volume_type(self) -> Optional[pulumi.Input[
|
|
1624
|
+
def volume_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1626
1625
|
"""
|
|
1627
1626
|
String. The type of the volume (example: "gp2").
|
|
1628
1627
|
"""
|
|
1629
1628
|
return pulumi.get(self, "volume_type")
|
|
1630
1629
|
|
|
1631
1630
|
@volume_type.setter
|
|
1632
|
-
def volume_type(self, value: Optional[pulumi.Input[
|
|
1631
|
+
def volume_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1633
1632
|
pulumi.set(self, "volume_type", value)
|
|
1634
1633
|
|
|
1635
1634
|
|
|
1636
1635
|
if not MYPY:
|
|
1637
1636
|
class OceanLaunchSpecBlockDeviceMappingEbsDynamicVolumeSizeArgsDict(TypedDict):
|
|
1638
|
-
base_size: pulumi.Input[
|
|
1637
|
+
base_size: pulumi.Input[_builtins.int]
|
|
1639
1638
|
"""
|
|
1640
1639
|
Int. Initial size for volume. (Example: 50)
|
|
1641
1640
|
"""
|
|
1642
|
-
resource: pulumi.Input[
|
|
1641
|
+
resource: pulumi.Input[_builtins.str]
|
|
1643
1642
|
"""
|
|
1644
1643
|
String. Resource type to increase volume size dynamically by. (valid values: "CPU")
|
|
1645
1644
|
"""
|
|
1646
|
-
size_per_resource_unit: pulumi.Input[
|
|
1645
|
+
size_per_resource_unit: pulumi.Input[_builtins.int]
|
|
1647
1646
|
"""
|
|
1648
1647
|
Int. Additional size (in GB) per resource unit. (Example: baseSize= 50, sizePerResourceUnit=20, and instance with 2 CPU is launched - its total disk size will be: 90GB)
|
|
1649
1648
|
"""
|
|
@@ -1653,58 +1652,58 @@ elif False:
|
|
|
1653
1652
|
@pulumi.input_type
|
|
1654
1653
|
class OceanLaunchSpecBlockDeviceMappingEbsDynamicVolumeSizeArgs:
|
|
1655
1654
|
def __init__(__self__, *,
|
|
1656
|
-
base_size: pulumi.Input[
|
|
1657
|
-
resource: pulumi.Input[
|
|
1658
|
-
size_per_resource_unit: pulumi.Input[
|
|
1655
|
+
base_size: pulumi.Input[_builtins.int],
|
|
1656
|
+
resource: pulumi.Input[_builtins.str],
|
|
1657
|
+
size_per_resource_unit: pulumi.Input[_builtins.int]):
|
|
1659
1658
|
"""
|
|
1660
|
-
:param pulumi.Input[
|
|
1661
|
-
:param pulumi.Input[
|
|
1662
|
-
:param pulumi.Input[
|
|
1659
|
+
:param pulumi.Input[_builtins.int] base_size: Int. Initial size for volume. (Example: 50)
|
|
1660
|
+
:param pulumi.Input[_builtins.str] resource: String. Resource type to increase volume size dynamically by. (valid values: "CPU")
|
|
1661
|
+
:param pulumi.Input[_builtins.int] size_per_resource_unit: Int. Additional size (in GB) per resource unit. (Example: baseSize= 50, sizePerResourceUnit=20, and instance with 2 CPU is launched - its total disk size will be: 90GB)
|
|
1663
1662
|
"""
|
|
1664
1663
|
pulumi.set(__self__, "base_size", base_size)
|
|
1665
1664
|
pulumi.set(__self__, "resource", resource)
|
|
1666
1665
|
pulumi.set(__self__, "size_per_resource_unit", size_per_resource_unit)
|
|
1667
1666
|
|
|
1668
|
-
@property
|
|
1667
|
+
@_builtins.property
|
|
1669
1668
|
@pulumi.getter(name="baseSize")
|
|
1670
|
-
def base_size(self) -> pulumi.Input[
|
|
1669
|
+
def base_size(self) -> pulumi.Input[_builtins.int]:
|
|
1671
1670
|
"""
|
|
1672
1671
|
Int. Initial size for volume. (Example: 50)
|
|
1673
1672
|
"""
|
|
1674
1673
|
return pulumi.get(self, "base_size")
|
|
1675
1674
|
|
|
1676
1675
|
@base_size.setter
|
|
1677
|
-
def base_size(self, value: pulumi.Input[
|
|
1676
|
+
def base_size(self, value: pulumi.Input[_builtins.int]):
|
|
1678
1677
|
pulumi.set(self, "base_size", value)
|
|
1679
1678
|
|
|
1680
|
-
@property
|
|
1679
|
+
@_builtins.property
|
|
1681
1680
|
@pulumi.getter
|
|
1682
|
-
def resource(self) -> pulumi.Input[
|
|
1681
|
+
def resource(self) -> pulumi.Input[_builtins.str]:
|
|
1683
1682
|
"""
|
|
1684
1683
|
String. Resource type to increase volume size dynamically by. (valid values: "CPU")
|
|
1685
1684
|
"""
|
|
1686
1685
|
return pulumi.get(self, "resource")
|
|
1687
1686
|
|
|
1688
1687
|
@resource.setter
|
|
1689
|
-
def resource(self, value: pulumi.Input[
|
|
1688
|
+
def resource(self, value: pulumi.Input[_builtins.str]):
|
|
1690
1689
|
pulumi.set(self, "resource", value)
|
|
1691
1690
|
|
|
1692
|
-
@property
|
|
1691
|
+
@_builtins.property
|
|
1693
1692
|
@pulumi.getter(name="sizePerResourceUnit")
|
|
1694
|
-
def size_per_resource_unit(self) -> pulumi.Input[
|
|
1693
|
+
def size_per_resource_unit(self) -> pulumi.Input[_builtins.int]:
|
|
1695
1694
|
"""
|
|
1696
1695
|
Int. Additional size (in GB) per resource unit. (Example: baseSize= 50, sizePerResourceUnit=20, and instance with 2 CPU is launched - its total disk size will be: 90GB)
|
|
1697
1696
|
"""
|
|
1698
1697
|
return pulumi.get(self, "size_per_resource_unit")
|
|
1699
1698
|
|
|
1700
1699
|
@size_per_resource_unit.setter
|
|
1701
|
-
def size_per_resource_unit(self, value: pulumi.Input[
|
|
1700
|
+
def size_per_resource_unit(self, value: pulumi.Input[_builtins.int]):
|
|
1702
1701
|
pulumi.set(self, "size_per_resource_unit", value)
|
|
1703
1702
|
|
|
1704
1703
|
|
|
1705
1704
|
if not MYPY:
|
|
1706
1705
|
class OceanLaunchSpecImageArgsDict(TypedDict):
|
|
1707
|
-
image_id: NotRequired[pulumi.Input[
|
|
1706
|
+
image_id: NotRequired[pulumi.Input[_builtins.str]]
|
|
1708
1707
|
"""
|
|
1709
1708
|
Identifier of the image in AWS. Valid values: any string which is not empty or null.
|
|
1710
1709
|
"""
|
|
@@ -1714,33 +1713,33 @@ elif False:
|
|
|
1714
1713
|
@pulumi.input_type
|
|
1715
1714
|
class OceanLaunchSpecImageArgs:
|
|
1716
1715
|
def __init__(__self__, *,
|
|
1717
|
-
image_id: Optional[pulumi.Input[
|
|
1716
|
+
image_id: Optional[pulumi.Input[_builtins.str]] = None):
|
|
1718
1717
|
"""
|
|
1719
|
-
:param pulumi.Input[
|
|
1718
|
+
:param pulumi.Input[_builtins.str] image_id: Identifier of the image in AWS. Valid values: any string which is not empty or null.
|
|
1720
1719
|
"""
|
|
1721
1720
|
if image_id is not None:
|
|
1722
1721
|
pulumi.set(__self__, "image_id", image_id)
|
|
1723
1722
|
|
|
1724
|
-
@property
|
|
1723
|
+
@_builtins.property
|
|
1725
1724
|
@pulumi.getter(name="imageId")
|
|
1726
|
-
def image_id(self) -> Optional[pulumi.Input[
|
|
1725
|
+
def image_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1727
1726
|
"""
|
|
1728
1727
|
Identifier of the image in AWS. Valid values: any string which is not empty or null.
|
|
1729
1728
|
"""
|
|
1730
1729
|
return pulumi.get(self, "image_id")
|
|
1731
1730
|
|
|
1732
1731
|
@image_id.setter
|
|
1733
|
-
def image_id(self, value: Optional[pulumi.Input[
|
|
1732
|
+
def image_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1734
1733
|
pulumi.set(self, "image_id", value)
|
|
1735
1734
|
|
|
1736
1735
|
|
|
1737
1736
|
if not MYPY:
|
|
1738
1737
|
class OceanLaunchSpecInstanceMetadataOptionsArgsDict(TypedDict):
|
|
1739
|
-
http_tokens: pulumi.Input[
|
|
1738
|
+
http_tokens: pulumi.Input[_builtins.str]
|
|
1740
1739
|
"""
|
|
1741
1740
|
Determines if a signed token is required or not. Valid values: `optional` or `required`.
|
|
1742
1741
|
"""
|
|
1743
|
-
http_put_response_hop_limit: NotRequired[pulumi.Input[
|
|
1742
|
+
http_put_response_hop_limit: NotRequired[pulumi.Input[_builtins.int]]
|
|
1744
1743
|
"""
|
|
1745
1744
|
An integer from 1 through 64. The desired HTTP PUT response hop limit for instance metadata requests. The larger the number, the further the instance metadata requests can travel.
|
|
1746
1745
|
"""
|
|
@@ -1750,52 +1749,52 @@ elif False:
|
|
|
1750
1749
|
@pulumi.input_type
|
|
1751
1750
|
class OceanLaunchSpecInstanceMetadataOptionsArgs:
|
|
1752
1751
|
def __init__(__self__, *,
|
|
1753
|
-
http_tokens: pulumi.Input[
|
|
1754
|
-
http_put_response_hop_limit: Optional[pulumi.Input[
|
|
1752
|
+
http_tokens: pulumi.Input[_builtins.str],
|
|
1753
|
+
http_put_response_hop_limit: Optional[pulumi.Input[_builtins.int]] = None):
|
|
1755
1754
|
"""
|
|
1756
|
-
:param pulumi.Input[
|
|
1757
|
-
:param pulumi.Input[
|
|
1755
|
+
:param pulumi.Input[_builtins.str] http_tokens: Determines if a signed token is required or not. Valid values: `optional` or `required`.
|
|
1756
|
+
:param pulumi.Input[_builtins.int] http_put_response_hop_limit: An integer from 1 through 64. The desired HTTP PUT response hop limit for instance metadata requests. The larger the number, the further the instance metadata requests can travel.
|
|
1758
1757
|
"""
|
|
1759
1758
|
pulumi.set(__self__, "http_tokens", http_tokens)
|
|
1760
1759
|
if http_put_response_hop_limit is not None:
|
|
1761
1760
|
pulumi.set(__self__, "http_put_response_hop_limit", http_put_response_hop_limit)
|
|
1762
1761
|
|
|
1763
|
-
@property
|
|
1762
|
+
@_builtins.property
|
|
1764
1763
|
@pulumi.getter(name="httpTokens")
|
|
1765
|
-
def http_tokens(self) -> pulumi.Input[
|
|
1764
|
+
def http_tokens(self) -> pulumi.Input[_builtins.str]:
|
|
1766
1765
|
"""
|
|
1767
1766
|
Determines if a signed token is required or not. Valid values: `optional` or `required`.
|
|
1768
1767
|
"""
|
|
1769
1768
|
return pulumi.get(self, "http_tokens")
|
|
1770
1769
|
|
|
1771
1770
|
@http_tokens.setter
|
|
1772
|
-
def http_tokens(self, value: pulumi.Input[
|
|
1771
|
+
def http_tokens(self, value: pulumi.Input[_builtins.str]):
|
|
1773
1772
|
pulumi.set(self, "http_tokens", value)
|
|
1774
1773
|
|
|
1775
|
-
@property
|
|
1774
|
+
@_builtins.property
|
|
1776
1775
|
@pulumi.getter(name="httpPutResponseHopLimit")
|
|
1777
|
-
def http_put_response_hop_limit(self) -> Optional[pulumi.Input[
|
|
1776
|
+
def http_put_response_hop_limit(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1778
1777
|
"""
|
|
1779
1778
|
An integer from 1 through 64. The desired HTTP PUT response hop limit for instance metadata requests. The larger the number, the further the instance metadata requests can travel.
|
|
1780
1779
|
"""
|
|
1781
1780
|
return pulumi.get(self, "http_put_response_hop_limit")
|
|
1782
1781
|
|
|
1783
1782
|
@http_put_response_hop_limit.setter
|
|
1784
|
-
def http_put_response_hop_limit(self, value: Optional[pulumi.Input[
|
|
1783
|
+
def http_put_response_hop_limit(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1785
1784
|
pulumi.set(self, "http_put_response_hop_limit", value)
|
|
1786
1785
|
|
|
1787
1786
|
|
|
1788
1787
|
if not MYPY:
|
|
1789
1788
|
class OceanLaunchSpecSchedulingTaskArgsDict(TypedDict):
|
|
1790
|
-
cron_expression: pulumi.Input[
|
|
1789
|
+
cron_expression: pulumi.Input[_builtins.str]
|
|
1791
1790
|
"""
|
|
1792
1791
|
A valid cron expression. For example : " * * * * * ". The cron job runs in UTC time and is in Unix cron format.
|
|
1793
1792
|
"""
|
|
1794
|
-
is_enabled: pulumi.Input[
|
|
1793
|
+
is_enabled: pulumi.Input[_builtins.bool]
|
|
1795
1794
|
"""
|
|
1796
1795
|
Describes whether the task is enabled. When `true`, the task runs. When `false`, it does not run.
|
|
1797
1796
|
"""
|
|
1798
|
-
task_type: pulumi.Input[
|
|
1797
|
+
task_type: pulumi.Input[_builtins.str]
|
|
1799
1798
|
"""
|
|
1800
1799
|
The activity that you are scheduling. Valid values: "manualHeadroomUpdate".
|
|
1801
1800
|
"""
|
|
@@ -1809,14 +1808,14 @@ elif False:
|
|
|
1809
1808
|
@pulumi.input_type
|
|
1810
1809
|
class OceanLaunchSpecSchedulingTaskArgs:
|
|
1811
1810
|
def __init__(__self__, *,
|
|
1812
|
-
cron_expression: pulumi.Input[
|
|
1813
|
-
is_enabled: pulumi.Input[
|
|
1814
|
-
task_type: pulumi.Input[
|
|
1811
|
+
cron_expression: pulumi.Input[_builtins.str],
|
|
1812
|
+
is_enabled: pulumi.Input[_builtins.bool],
|
|
1813
|
+
task_type: pulumi.Input[_builtins.str],
|
|
1815
1814
|
task_headrooms: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecSchedulingTaskTaskHeadroomArgs']]]] = None):
|
|
1816
1815
|
"""
|
|
1817
|
-
:param pulumi.Input[
|
|
1818
|
-
:param pulumi.Input[
|
|
1819
|
-
:param pulumi.Input[
|
|
1816
|
+
: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.
|
|
1817
|
+
:param pulumi.Input[_builtins.bool] is_enabled: Describes whether the task is enabled. When `true`, the task runs. When `false`, it does not run.
|
|
1818
|
+
:param pulumi.Input[_builtins.str] task_type: The activity that you are scheduling. Valid values: "manualHeadroomUpdate".
|
|
1820
1819
|
:param pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecSchedulingTaskTaskHeadroomArgs']]] task_headrooms: The config of this scheduled task. Depends on the value of taskType.
|
|
1821
1820
|
"""
|
|
1822
1821
|
pulumi.set(__self__, "cron_expression", cron_expression)
|
|
@@ -1825,43 +1824,43 @@ class OceanLaunchSpecSchedulingTaskArgs:
|
|
|
1825
1824
|
if task_headrooms is not None:
|
|
1826
1825
|
pulumi.set(__self__, "task_headrooms", task_headrooms)
|
|
1827
1826
|
|
|
1828
|
-
@property
|
|
1827
|
+
@_builtins.property
|
|
1829
1828
|
@pulumi.getter(name="cronExpression")
|
|
1830
|
-
def cron_expression(self) -> pulumi.Input[
|
|
1829
|
+
def cron_expression(self) -> pulumi.Input[_builtins.str]:
|
|
1831
1830
|
"""
|
|
1832
1831
|
A valid cron expression. For example : " * * * * * ". The cron job runs in UTC time and is in Unix cron format.
|
|
1833
1832
|
"""
|
|
1834
1833
|
return pulumi.get(self, "cron_expression")
|
|
1835
1834
|
|
|
1836
1835
|
@cron_expression.setter
|
|
1837
|
-
def cron_expression(self, value: pulumi.Input[
|
|
1836
|
+
def cron_expression(self, value: pulumi.Input[_builtins.str]):
|
|
1838
1837
|
pulumi.set(self, "cron_expression", value)
|
|
1839
1838
|
|
|
1840
|
-
@property
|
|
1839
|
+
@_builtins.property
|
|
1841
1840
|
@pulumi.getter(name="isEnabled")
|
|
1842
|
-
def is_enabled(self) -> pulumi.Input[
|
|
1841
|
+
def is_enabled(self) -> pulumi.Input[_builtins.bool]:
|
|
1843
1842
|
"""
|
|
1844
1843
|
Describes whether the task is enabled. When `true`, the task runs. When `false`, it does not run.
|
|
1845
1844
|
"""
|
|
1846
1845
|
return pulumi.get(self, "is_enabled")
|
|
1847
1846
|
|
|
1848
1847
|
@is_enabled.setter
|
|
1849
|
-
def is_enabled(self, value: pulumi.Input[
|
|
1848
|
+
def is_enabled(self, value: pulumi.Input[_builtins.bool]):
|
|
1850
1849
|
pulumi.set(self, "is_enabled", value)
|
|
1851
1850
|
|
|
1852
|
-
@property
|
|
1851
|
+
@_builtins.property
|
|
1853
1852
|
@pulumi.getter(name="taskType")
|
|
1854
|
-
def task_type(self) -> pulumi.Input[
|
|
1853
|
+
def task_type(self) -> pulumi.Input[_builtins.str]:
|
|
1855
1854
|
"""
|
|
1856
1855
|
The activity that you are scheduling. Valid values: "manualHeadroomUpdate".
|
|
1857
1856
|
"""
|
|
1858
1857
|
return pulumi.get(self, "task_type")
|
|
1859
1858
|
|
|
1860
1859
|
@task_type.setter
|
|
1861
|
-
def task_type(self, value: pulumi.Input[
|
|
1860
|
+
def task_type(self, value: pulumi.Input[_builtins.str]):
|
|
1862
1861
|
pulumi.set(self, "task_type", value)
|
|
1863
1862
|
|
|
1864
|
-
@property
|
|
1863
|
+
@_builtins.property
|
|
1865
1864
|
@pulumi.getter(name="taskHeadrooms")
|
|
1866
1865
|
def task_headrooms(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecSchedulingTaskTaskHeadroomArgs']]]]:
|
|
1867
1866
|
"""
|
|
@@ -1876,15 +1875,15 @@ class OceanLaunchSpecSchedulingTaskArgs:
|
|
|
1876
1875
|
|
|
1877
1876
|
if not MYPY:
|
|
1878
1877
|
class OceanLaunchSpecSchedulingTaskTaskHeadroomArgsDict(TypedDict):
|
|
1879
|
-
num_of_units: pulumi.Input[
|
|
1878
|
+
num_of_units: pulumi.Input[_builtins.int]
|
|
1880
1879
|
"""
|
|
1881
1880
|
The number of units to retain as headroom, where each unit has the defined headroom CPU, memory and GPU.
|
|
1882
1881
|
"""
|
|
1883
|
-
cpu_per_unit: NotRequired[pulumi.Input[
|
|
1882
|
+
cpu_per_unit: NotRequired[pulumi.Input[_builtins.int]]
|
|
1884
1883
|
"""
|
|
1885
1884
|
Optionally configure the number of CPUs to allocate for each headroom unit. CPUs are denoted in millicores, where 1000 millicores = 1 vCPU.
|
|
1886
1885
|
"""
|
|
1887
|
-
memory_per_unit: NotRequired[pulumi.Input[
|
|
1886
|
+
memory_per_unit: NotRequired[pulumi.Input[_builtins.int]]
|
|
1888
1887
|
"""
|
|
1889
1888
|
Optionally configure the amount of memory (MiB) to allocate for each headroom unit.
|
|
1890
1889
|
"""
|
|
@@ -1894,13 +1893,13 @@ elif False:
|
|
|
1894
1893
|
@pulumi.input_type
|
|
1895
1894
|
class OceanLaunchSpecSchedulingTaskTaskHeadroomArgs:
|
|
1896
1895
|
def __init__(__self__, *,
|
|
1897
|
-
num_of_units: pulumi.Input[
|
|
1898
|
-
cpu_per_unit: Optional[pulumi.Input[
|
|
1899
|
-
memory_per_unit: Optional[pulumi.Input[
|
|
1896
|
+
num_of_units: pulumi.Input[_builtins.int],
|
|
1897
|
+
cpu_per_unit: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1898
|
+
memory_per_unit: Optional[pulumi.Input[_builtins.int]] = None):
|
|
1900
1899
|
"""
|
|
1901
|
-
:param pulumi.Input[
|
|
1902
|
-
:param pulumi.Input[
|
|
1903
|
-
:param pulumi.Input[
|
|
1900
|
+
: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.
|
|
1901
|
+
: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.
|
|
1902
|
+
:param pulumi.Input[_builtins.int] memory_per_unit: Optionally configure the amount of memory (MiB) to allocate for each headroom unit.
|
|
1904
1903
|
"""
|
|
1905
1904
|
pulumi.set(__self__, "num_of_units", num_of_units)
|
|
1906
1905
|
if cpu_per_unit is not None:
|
|
@@ -1908,46 +1907,46 @@ class OceanLaunchSpecSchedulingTaskTaskHeadroomArgs:
|
|
|
1908
1907
|
if memory_per_unit is not None:
|
|
1909
1908
|
pulumi.set(__self__, "memory_per_unit", memory_per_unit)
|
|
1910
1909
|
|
|
1911
|
-
@property
|
|
1910
|
+
@_builtins.property
|
|
1912
1911
|
@pulumi.getter(name="numOfUnits")
|
|
1913
|
-
def num_of_units(self) -> pulumi.Input[
|
|
1912
|
+
def num_of_units(self) -> pulumi.Input[_builtins.int]:
|
|
1914
1913
|
"""
|
|
1915
1914
|
The number of units to retain as headroom, where each unit has the defined headroom CPU, memory and GPU.
|
|
1916
1915
|
"""
|
|
1917
1916
|
return pulumi.get(self, "num_of_units")
|
|
1918
1917
|
|
|
1919
1918
|
@num_of_units.setter
|
|
1920
|
-
def num_of_units(self, value: pulumi.Input[
|
|
1919
|
+
def num_of_units(self, value: pulumi.Input[_builtins.int]):
|
|
1921
1920
|
pulumi.set(self, "num_of_units", value)
|
|
1922
1921
|
|
|
1923
|
-
@property
|
|
1922
|
+
@_builtins.property
|
|
1924
1923
|
@pulumi.getter(name="cpuPerUnit")
|
|
1925
|
-
def cpu_per_unit(self) -> Optional[pulumi.Input[
|
|
1924
|
+
def cpu_per_unit(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1926
1925
|
"""
|
|
1927
1926
|
Optionally configure the number of CPUs to allocate for each headroom unit. CPUs are denoted in millicores, where 1000 millicores = 1 vCPU.
|
|
1928
1927
|
"""
|
|
1929
1928
|
return pulumi.get(self, "cpu_per_unit")
|
|
1930
1929
|
|
|
1931
1930
|
@cpu_per_unit.setter
|
|
1932
|
-
def cpu_per_unit(self, value: Optional[pulumi.Input[
|
|
1931
|
+
def cpu_per_unit(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1933
1932
|
pulumi.set(self, "cpu_per_unit", value)
|
|
1934
1933
|
|
|
1935
|
-
@property
|
|
1934
|
+
@_builtins.property
|
|
1936
1935
|
@pulumi.getter(name="memoryPerUnit")
|
|
1937
|
-
def memory_per_unit(self) -> Optional[pulumi.Input[
|
|
1936
|
+
def memory_per_unit(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1938
1937
|
"""
|
|
1939
1938
|
Optionally configure the amount of memory (MiB) to allocate for each headroom unit.
|
|
1940
1939
|
"""
|
|
1941
1940
|
return pulumi.get(self, "memory_per_unit")
|
|
1942
1941
|
|
|
1943
1942
|
@memory_per_unit.setter
|
|
1944
|
-
def memory_per_unit(self, value: Optional[pulumi.Input[
|
|
1943
|
+
def memory_per_unit(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1945
1944
|
pulumi.set(self, "memory_per_unit", value)
|
|
1946
1945
|
|
|
1947
1946
|
|
|
1948
1947
|
if not MYPY:
|
|
1949
1948
|
class OceanLaunchSpecStrategyArgsDict(TypedDict):
|
|
1950
|
-
spot_percentage: NotRequired[pulumi.Input[
|
|
1949
|
+
spot_percentage: NotRequired[pulumi.Input[_builtins.int]]
|
|
1951
1950
|
"""
|
|
1952
1951
|
When set, Ocean will proactively try to maintain as close as possible to the percentage of Spot instances out of all the Virtual Node Group instances.
|
|
1953
1952
|
"""
|
|
@@ -1957,33 +1956,33 @@ elif False:
|
|
|
1957
1956
|
@pulumi.input_type
|
|
1958
1957
|
class OceanLaunchSpecStrategyArgs:
|
|
1959
1958
|
def __init__(__self__, *,
|
|
1960
|
-
spot_percentage: Optional[pulumi.Input[
|
|
1959
|
+
spot_percentage: Optional[pulumi.Input[_builtins.int]] = None):
|
|
1961
1960
|
"""
|
|
1962
|
-
:param pulumi.Input[
|
|
1961
|
+
:param pulumi.Input[_builtins.int] spot_percentage: When set, Ocean will proactively try to maintain as close as possible to the percentage of Spot instances out of all the Virtual Node Group instances.
|
|
1963
1962
|
"""
|
|
1964
1963
|
if spot_percentage is not None:
|
|
1965
1964
|
pulumi.set(__self__, "spot_percentage", spot_percentage)
|
|
1966
1965
|
|
|
1967
|
-
@property
|
|
1966
|
+
@_builtins.property
|
|
1968
1967
|
@pulumi.getter(name="spotPercentage")
|
|
1969
|
-
def spot_percentage(self) -> Optional[pulumi.Input[
|
|
1968
|
+
def spot_percentage(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1970
1969
|
"""
|
|
1971
1970
|
When set, Ocean will proactively try to maintain as close as possible to the percentage of Spot instances out of all the Virtual Node Group instances.
|
|
1972
1971
|
"""
|
|
1973
1972
|
return pulumi.get(self, "spot_percentage")
|
|
1974
1973
|
|
|
1975
1974
|
@spot_percentage.setter
|
|
1976
|
-
def spot_percentage(self, value: Optional[pulumi.Input[
|
|
1975
|
+
def spot_percentage(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1977
1976
|
pulumi.set(self, "spot_percentage", value)
|
|
1978
1977
|
|
|
1979
1978
|
|
|
1980
1979
|
if not MYPY:
|
|
1981
1980
|
class OceanLaunchSpecTagArgsDict(TypedDict):
|
|
1982
|
-
key: pulumi.Input[
|
|
1981
|
+
key: pulumi.Input[_builtins.str]
|
|
1983
1982
|
"""
|
|
1984
1983
|
The label key.
|
|
1985
1984
|
"""
|
|
1986
|
-
value: pulumi.Input[
|
|
1985
|
+
value: pulumi.Input[_builtins.str]
|
|
1987
1986
|
"""
|
|
1988
1987
|
The label value.
|
|
1989
1988
|
"""
|
|
@@ -1993,37 +1992,37 @@ elif False:
|
|
|
1993
1992
|
@pulumi.input_type
|
|
1994
1993
|
class OceanLaunchSpecTagArgs:
|
|
1995
1994
|
def __init__(__self__, *,
|
|
1996
|
-
key: pulumi.Input[
|
|
1997
|
-
value: pulumi.Input[
|
|
1995
|
+
key: pulumi.Input[_builtins.str],
|
|
1996
|
+
value: pulumi.Input[_builtins.str]):
|
|
1998
1997
|
"""
|
|
1999
|
-
:param pulumi.Input[
|
|
2000
|
-
:param pulumi.Input[
|
|
1998
|
+
:param pulumi.Input[_builtins.str] key: The label key.
|
|
1999
|
+
:param pulumi.Input[_builtins.str] value: The label value.
|
|
2001
2000
|
"""
|
|
2002
2001
|
pulumi.set(__self__, "key", key)
|
|
2003
2002
|
pulumi.set(__self__, "value", value)
|
|
2004
2003
|
|
|
2005
|
-
@property
|
|
2004
|
+
@_builtins.property
|
|
2006
2005
|
@pulumi.getter
|
|
2007
|
-
def key(self) -> pulumi.Input[
|
|
2006
|
+
def key(self) -> pulumi.Input[_builtins.str]:
|
|
2008
2007
|
"""
|
|
2009
2008
|
The label key.
|
|
2010
2009
|
"""
|
|
2011
2010
|
return pulumi.get(self, "key")
|
|
2012
2011
|
|
|
2013
2012
|
@key.setter
|
|
2014
|
-
def key(self, value: pulumi.Input[
|
|
2013
|
+
def key(self, value: pulumi.Input[_builtins.str]):
|
|
2015
2014
|
pulumi.set(self, "key", value)
|
|
2016
2015
|
|
|
2017
|
-
@property
|
|
2016
|
+
@_builtins.property
|
|
2018
2017
|
@pulumi.getter
|
|
2019
|
-
def value(self) -> pulumi.Input[
|
|
2018
|
+
def value(self) -> pulumi.Input[_builtins.str]:
|
|
2020
2019
|
"""
|
|
2021
2020
|
The label value.
|
|
2022
2021
|
"""
|
|
2023
2022
|
return pulumi.get(self, "value")
|
|
2024
2023
|
|
|
2025
2024
|
@value.setter
|
|
2026
|
-
def value(self, value: pulumi.Input[
|
|
2025
|
+
def value(self, value: pulumi.Input[_builtins.str]):
|
|
2027
2026
|
pulumi.set(self, "value", value)
|
|
2028
2027
|
|
|
2029
2028
|
|
|
@@ -2046,7 +2045,7 @@ class OceanLoggingArgs:
|
|
|
2046
2045
|
if export is not None:
|
|
2047
2046
|
pulumi.set(__self__, "export", export)
|
|
2048
2047
|
|
|
2049
|
-
@property
|
|
2048
|
+
@_builtins.property
|
|
2050
2049
|
@pulumi.getter
|
|
2051
2050
|
def export(self) -> Optional[pulumi.Input['OceanLoggingExportArgs']]:
|
|
2052
2051
|
"""
|
|
@@ -2078,7 +2077,7 @@ class OceanLoggingExportArgs:
|
|
|
2078
2077
|
if s3s is not None:
|
|
2079
2078
|
pulumi.set(__self__, "s3s", s3s)
|
|
2080
2079
|
|
|
2081
|
-
@property
|
|
2080
|
+
@_builtins.property
|
|
2082
2081
|
@pulumi.getter
|
|
2083
2082
|
def s3s(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanLoggingExportS3Args']]]]:
|
|
2084
2083
|
"""
|
|
@@ -2093,7 +2092,7 @@ class OceanLoggingExportArgs:
|
|
|
2093
2092
|
|
|
2094
2093
|
if not MYPY:
|
|
2095
2094
|
class OceanLoggingExportS3ArgsDict(TypedDict):
|
|
2096
|
-
id: pulumi.Input[
|
|
2095
|
+
id: pulumi.Input[_builtins.str]
|
|
2097
2096
|
"""
|
|
2098
2097
|
The identifier of The S3 data integration to export the logs to.
|
|
2099
2098
|
"""
|
|
@@ -2103,36 +2102,36 @@ elif False:
|
|
|
2103
2102
|
@pulumi.input_type
|
|
2104
2103
|
class OceanLoggingExportS3Args:
|
|
2105
2104
|
def __init__(__self__, *,
|
|
2106
|
-
id: pulumi.Input[
|
|
2105
|
+
id: pulumi.Input[_builtins.str]):
|
|
2107
2106
|
"""
|
|
2108
|
-
:param pulumi.Input[
|
|
2107
|
+
:param pulumi.Input[_builtins.str] id: The identifier of The S3 data integration to export the logs to.
|
|
2109
2108
|
"""
|
|
2110
2109
|
pulumi.set(__self__, "id", id)
|
|
2111
2110
|
|
|
2112
|
-
@property
|
|
2111
|
+
@_builtins.property
|
|
2113
2112
|
@pulumi.getter
|
|
2114
|
-
def id(self) -> pulumi.Input[
|
|
2113
|
+
def id(self) -> pulumi.Input[_builtins.str]:
|
|
2115
2114
|
"""
|
|
2116
2115
|
The identifier of The S3 data integration to export the logs to.
|
|
2117
2116
|
"""
|
|
2118
2117
|
return pulumi.get(self, "id")
|
|
2119
2118
|
|
|
2120
2119
|
@id.setter
|
|
2121
|
-
def id(self, value: pulumi.Input[
|
|
2120
|
+
def id(self, value: pulumi.Input[_builtins.str]):
|
|
2122
2121
|
pulumi.set(self, "id", value)
|
|
2123
2122
|
|
|
2124
2123
|
|
|
2125
2124
|
if not MYPY:
|
|
2126
2125
|
class OceanOptimizeImagesArgsDict(TypedDict):
|
|
2127
|
-
perform_at: pulumi.Input[
|
|
2126
|
+
perform_at: pulumi.Input[_builtins.str]
|
|
2128
2127
|
"""
|
|
2129
2128
|
String. Valid values: "always" "never" "timeWindow".
|
|
2130
2129
|
"""
|
|
2131
|
-
should_optimize_ecs_ami: pulumi.Input[
|
|
2130
|
+
should_optimize_ecs_ami: pulumi.Input[_builtins.bool]
|
|
2132
2131
|
"""
|
|
2133
2132
|
Boolean. Enable auto image (AMI) update for the ECS container instances. The auto update applies for ECS-Optimized AMIs.
|
|
2134
2133
|
"""
|
|
2135
|
-
time_windows: NotRequired[pulumi.Input[Sequence[pulumi.Input[
|
|
2134
|
+
time_windows: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
2136
2135
|
"""
|
|
2137
2136
|
Array of strings. Set time windows for image update, at least one time window. Each string is in the format of ddd:hh:mm-ddd:hh:mm ddd. Time windows should not overlap.
|
|
2138
2137
|
"""
|
|
@@ -2142,53 +2141,53 @@ elif False:
|
|
|
2142
2141
|
@pulumi.input_type
|
|
2143
2142
|
class OceanOptimizeImagesArgs:
|
|
2144
2143
|
def __init__(__self__, *,
|
|
2145
|
-
perform_at: pulumi.Input[
|
|
2146
|
-
should_optimize_ecs_ami: pulumi.Input[
|
|
2147
|
-
time_windows: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
2144
|
+
perform_at: pulumi.Input[_builtins.str],
|
|
2145
|
+
should_optimize_ecs_ami: pulumi.Input[_builtins.bool],
|
|
2146
|
+
time_windows: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
|
|
2148
2147
|
"""
|
|
2149
|
-
:param pulumi.Input[
|
|
2150
|
-
:param pulumi.Input[
|
|
2151
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
2148
|
+
:param pulumi.Input[_builtins.str] perform_at: String. Valid values: "always" "never" "timeWindow".
|
|
2149
|
+
:param pulumi.Input[_builtins.bool] should_optimize_ecs_ami: Boolean. Enable auto image (AMI) update for the ECS container instances. The auto update applies for ECS-Optimized AMIs.
|
|
2150
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] time_windows: Array of strings. Set time windows for image update, at least one time window. Each string is in the format of ddd:hh:mm-ddd:hh:mm ddd. Time windows should not overlap.
|
|
2152
2151
|
"""
|
|
2153
2152
|
pulumi.set(__self__, "perform_at", perform_at)
|
|
2154
2153
|
pulumi.set(__self__, "should_optimize_ecs_ami", should_optimize_ecs_ami)
|
|
2155
2154
|
if time_windows is not None:
|
|
2156
2155
|
pulumi.set(__self__, "time_windows", time_windows)
|
|
2157
2156
|
|
|
2158
|
-
@property
|
|
2157
|
+
@_builtins.property
|
|
2159
2158
|
@pulumi.getter(name="performAt")
|
|
2160
|
-
def perform_at(self) -> pulumi.Input[
|
|
2159
|
+
def perform_at(self) -> pulumi.Input[_builtins.str]:
|
|
2161
2160
|
"""
|
|
2162
2161
|
String. Valid values: "always" "never" "timeWindow".
|
|
2163
2162
|
"""
|
|
2164
2163
|
return pulumi.get(self, "perform_at")
|
|
2165
2164
|
|
|
2166
2165
|
@perform_at.setter
|
|
2167
|
-
def perform_at(self, value: pulumi.Input[
|
|
2166
|
+
def perform_at(self, value: pulumi.Input[_builtins.str]):
|
|
2168
2167
|
pulumi.set(self, "perform_at", value)
|
|
2169
2168
|
|
|
2170
|
-
@property
|
|
2169
|
+
@_builtins.property
|
|
2171
2170
|
@pulumi.getter(name="shouldOptimizeEcsAmi")
|
|
2172
|
-
def should_optimize_ecs_ami(self) -> pulumi.Input[
|
|
2171
|
+
def should_optimize_ecs_ami(self) -> pulumi.Input[_builtins.bool]:
|
|
2173
2172
|
"""
|
|
2174
2173
|
Boolean. Enable auto image (AMI) update for the ECS container instances. The auto update applies for ECS-Optimized AMIs.
|
|
2175
2174
|
"""
|
|
2176
2175
|
return pulumi.get(self, "should_optimize_ecs_ami")
|
|
2177
2176
|
|
|
2178
2177
|
@should_optimize_ecs_ami.setter
|
|
2179
|
-
def should_optimize_ecs_ami(self, value: pulumi.Input[
|
|
2178
|
+
def should_optimize_ecs_ami(self, value: pulumi.Input[_builtins.bool]):
|
|
2180
2179
|
pulumi.set(self, "should_optimize_ecs_ami", value)
|
|
2181
2180
|
|
|
2182
|
-
@property
|
|
2181
|
+
@_builtins.property
|
|
2183
2182
|
@pulumi.getter(name="timeWindows")
|
|
2184
|
-
def time_windows(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
2183
|
+
def time_windows(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
2185
2184
|
"""
|
|
2186
2185
|
Array of strings. Set time windows for image update, at least one time window. Each string is in the format of ddd:hh:mm-ddd:hh:mm ddd. Time windows should not overlap.
|
|
2187
2186
|
"""
|
|
2188
2187
|
return pulumi.get(self, "time_windows")
|
|
2189
2188
|
|
|
2190
2189
|
@time_windows.setter
|
|
2191
|
-
def time_windows(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
2190
|
+
def time_windows(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
2192
2191
|
pulumi.set(self, "time_windows", value)
|
|
2193
2192
|
|
|
2194
2193
|
|
|
@@ -2219,7 +2218,7 @@ class OceanScheduledTaskArgs:
|
|
|
2219
2218
|
if tasks is not None:
|
|
2220
2219
|
pulumi.set(__self__, "tasks", tasks)
|
|
2221
2220
|
|
|
2222
|
-
@property
|
|
2221
|
+
@_builtins.property
|
|
2223
2222
|
@pulumi.getter(name="shutdownHours")
|
|
2224
2223
|
def shutdown_hours(self) -> Optional[pulumi.Input['OceanScheduledTaskShutdownHoursArgs']]:
|
|
2225
2224
|
"""
|
|
@@ -2231,7 +2230,7 @@ class OceanScheduledTaskArgs:
|
|
|
2231
2230
|
def shutdown_hours(self, value: Optional[pulumi.Input['OceanScheduledTaskShutdownHoursArgs']]):
|
|
2232
2231
|
pulumi.set(self, "shutdown_hours", value)
|
|
2233
2232
|
|
|
2234
|
-
@property
|
|
2233
|
+
@_builtins.property
|
|
2235
2234
|
@pulumi.getter
|
|
2236
2235
|
def tasks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanScheduledTaskTaskArgs']]]]:
|
|
2237
2236
|
"""
|
|
@@ -2246,11 +2245,11 @@ class OceanScheduledTaskArgs:
|
|
|
2246
2245
|
|
|
2247
2246
|
if not MYPY:
|
|
2248
2247
|
class OceanScheduledTaskShutdownHoursArgsDict(TypedDict):
|
|
2249
|
-
time_windows: pulumi.Input[Sequence[pulumi.Input[
|
|
2248
|
+
time_windows: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]
|
|
2250
2249
|
"""
|
|
2251
2250
|
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 when `cluster.scheduling.isEnabled` is true. API Times are in UTC. Example: `Fri:15:30-Wed:14:30`.
|
|
2252
2251
|
"""
|
|
2253
|
-
is_enabled: NotRequired[pulumi.Input[
|
|
2252
|
+
is_enabled: NotRequired[pulumi.Input[_builtins.bool]]
|
|
2254
2253
|
"""
|
|
2255
2254
|
Flag to enable / disable the shutdown hours.
|
|
2256
2255
|
"""
|
|
@@ -2260,52 +2259,52 @@ elif False:
|
|
|
2260
2259
|
@pulumi.input_type
|
|
2261
2260
|
class OceanScheduledTaskShutdownHoursArgs:
|
|
2262
2261
|
def __init__(__self__, *,
|
|
2263
|
-
time_windows: pulumi.Input[Sequence[pulumi.Input[
|
|
2264
|
-
is_enabled: Optional[pulumi.Input[
|
|
2262
|
+
time_windows: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]],
|
|
2263
|
+
is_enabled: Optional[pulumi.Input[_builtins.bool]] = None):
|
|
2265
2264
|
"""
|
|
2266
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
2267
|
-
:param pulumi.Input[
|
|
2265
|
+
: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 when `cluster.scheduling.isEnabled` is true. API Times are in UTC. Example: `Fri:15:30-Wed:14:30`.
|
|
2266
|
+
:param pulumi.Input[_builtins.bool] is_enabled: Flag to enable / disable the shutdown hours.
|
|
2268
2267
|
"""
|
|
2269
2268
|
pulumi.set(__self__, "time_windows", time_windows)
|
|
2270
2269
|
if is_enabled is not None:
|
|
2271
2270
|
pulumi.set(__self__, "is_enabled", is_enabled)
|
|
2272
2271
|
|
|
2273
|
-
@property
|
|
2272
|
+
@_builtins.property
|
|
2274
2273
|
@pulumi.getter(name="timeWindows")
|
|
2275
|
-
def time_windows(self) -> pulumi.Input[Sequence[pulumi.Input[
|
|
2274
|
+
def time_windows(self) -> pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]:
|
|
2276
2275
|
"""
|
|
2277
2276
|
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 when `cluster.scheduling.isEnabled` is true. API Times are in UTC. Example: `Fri:15:30-Wed:14:30`.
|
|
2278
2277
|
"""
|
|
2279
2278
|
return pulumi.get(self, "time_windows")
|
|
2280
2279
|
|
|
2281
2280
|
@time_windows.setter
|
|
2282
|
-
def time_windows(self, value: pulumi.Input[Sequence[pulumi.Input[
|
|
2281
|
+
def time_windows(self, value: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]):
|
|
2283
2282
|
pulumi.set(self, "time_windows", value)
|
|
2284
2283
|
|
|
2285
|
-
@property
|
|
2284
|
+
@_builtins.property
|
|
2286
2285
|
@pulumi.getter(name="isEnabled")
|
|
2287
|
-
def is_enabled(self) -> Optional[pulumi.Input[
|
|
2286
|
+
def is_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
2288
2287
|
"""
|
|
2289
2288
|
Flag to enable / disable the shutdown hours.
|
|
2290
2289
|
"""
|
|
2291
2290
|
return pulumi.get(self, "is_enabled")
|
|
2292
2291
|
|
|
2293
2292
|
@is_enabled.setter
|
|
2294
|
-
def is_enabled(self, value: Optional[pulumi.Input[
|
|
2293
|
+
def is_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
2295
2294
|
pulumi.set(self, "is_enabled", value)
|
|
2296
2295
|
|
|
2297
2296
|
|
|
2298
2297
|
if not MYPY:
|
|
2299
2298
|
class OceanScheduledTaskTaskArgsDict(TypedDict):
|
|
2300
|
-
cron_expression: pulumi.Input[
|
|
2299
|
+
cron_expression: pulumi.Input[_builtins.str]
|
|
2301
2300
|
"""
|
|
2302
2301
|
A valid cron expression. 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. Example: `0 1 * * *`.
|
|
2303
2302
|
"""
|
|
2304
|
-
is_enabled: pulumi.Input[
|
|
2303
|
+
is_enabled: pulumi.Input[_builtins.bool]
|
|
2305
2304
|
"""
|
|
2306
2305
|
Describes whether the task is enabled. When true the task should run when false it should not run. Required for `cluster.scheduling.tasks` object.
|
|
2307
2306
|
"""
|
|
2308
|
-
task_type: pulumi.Input[
|
|
2307
|
+
task_type: pulumi.Input[_builtins.str]
|
|
2309
2308
|
"""
|
|
2310
2309
|
Valid values: "clusterRoll". Required for `cluster.scheduling.tasks object`. Example: `clusterRoll`.
|
|
2311
2310
|
"""
|
|
@@ -2315,62 +2314,62 @@ elif False:
|
|
|
2315
2314
|
@pulumi.input_type
|
|
2316
2315
|
class OceanScheduledTaskTaskArgs:
|
|
2317
2316
|
def __init__(__self__, *,
|
|
2318
|
-
cron_expression: pulumi.Input[
|
|
2319
|
-
is_enabled: pulumi.Input[
|
|
2320
|
-
task_type: pulumi.Input[
|
|
2317
|
+
cron_expression: pulumi.Input[_builtins.str],
|
|
2318
|
+
is_enabled: pulumi.Input[_builtins.bool],
|
|
2319
|
+
task_type: pulumi.Input[_builtins.str]):
|
|
2321
2320
|
"""
|
|
2322
|
-
:param pulumi.Input[
|
|
2323
|
-
:param pulumi.Input[
|
|
2324
|
-
:param pulumi.Input[
|
|
2321
|
+
:param pulumi.Input[_builtins.str] cron_expression: A valid cron expression. 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. Example: `0 1 * * *`.
|
|
2322
|
+
: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.
|
|
2323
|
+
:param pulumi.Input[_builtins.str] task_type: Valid values: "clusterRoll". Required for `cluster.scheduling.tasks object`. Example: `clusterRoll`.
|
|
2325
2324
|
"""
|
|
2326
2325
|
pulumi.set(__self__, "cron_expression", cron_expression)
|
|
2327
2326
|
pulumi.set(__self__, "is_enabled", is_enabled)
|
|
2328
2327
|
pulumi.set(__self__, "task_type", task_type)
|
|
2329
2328
|
|
|
2330
|
-
@property
|
|
2329
|
+
@_builtins.property
|
|
2331
2330
|
@pulumi.getter(name="cronExpression")
|
|
2332
|
-
def cron_expression(self) -> pulumi.Input[
|
|
2331
|
+
def cron_expression(self) -> pulumi.Input[_builtins.str]:
|
|
2333
2332
|
"""
|
|
2334
2333
|
A valid cron expression. 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. Example: `0 1 * * *`.
|
|
2335
2334
|
"""
|
|
2336
2335
|
return pulumi.get(self, "cron_expression")
|
|
2337
2336
|
|
|
2338
2337
|
@cron_expression.setter
|
|
2339
|
-
def cron_expression(self, value: pulumi.Input[
|
|
2338
|
+
def cron_expression(self, value: pulumi.Input[_builtins.str]):
|
|
2340
2339
|
pulumi.set(self, "cron_expression", value)
|
|
2341
2340
|
|
|
2342
|
-
@property
|
|
2341
|
+
@_builtins.property
|
|
2343
2342
|
@pulumi.getter(name="isEnabled")
|
|
2344
|
-
def is_enabled(self) -> pulumi.Input[
|
|
2343
|
+
def is_enabled(self) -> pulumi.Input[_builtins.bool]:
|
|
2345
2344
|
"""
|
|
2346
2345
|
Describes whether the task is enabled. When true the task should run when false it should not run. Required for `cluster.scheduling.tasks` object.
|
|
2347
2346
|
"""
|
|
2348
2347
|
return pulumi.get(self, "is_enabled")
|
|
2349
2348
|
|
|
2350
2349
|
@is_enabled.setter
|
|
2351
|
-
def is_enabled(self, value: pulumi.Input[
|
|
2350
|
+
def is_enabled(self, value: pulumi.Input[_builtins.bool]):
|
|
2352
2351
|
pulumi.set(self, "is_enabled", value)
|
|
2353
2352
|
|
|
2354
|
-
@property
|
|
2353
|
+
@_builtins.property
|
|
2355
2354
|
@pulumi.getter(name="taskType")
|
|
2356
|
-
def task_type(self) -> pulumi.Input[
|
|
2355
|
+
def task_type(self) -> pulumi.Input[_builtins.str]:
|
|
2357
2356
|
"""
|
|
2358
2357
|
Valid values: "clusterRoll". Required for `cluster.scheduling.tasks object`. Example: `clusterRoll`.
|
|
2359
2358
|
"""
|
|
2360
2359
|
return pulumi.get(self, "task_type")
|
|
2361
2360
|
|
|
2362
2361
|
@task_type.setter
|
|
2363
|
-
def task_type(self, value: pulumi.Input[
|
|
2362
|
+
def task_type(self, value: pulumi.Input[_builtins.str]):
|
|
2364
2363
|
pulumi.set(self, "task_type", value)
|
|
2365
2364
|
|
|
2366
2365
|
|
|
2367
2366
|
if not MYPY:
|
|
2368
2367
|
class OceanTagArgsDict(TypedDict):
|
|
2369
|
-
key: pulumi.Input[
|
|
2368
|
+
key: pulumi.Input[_builtins.str]
|
|
2370
2369
|
"""
|
|
2371
2370
|
The tag key.
|
|
2372
2371
|
"""
|
|
2373
|
-
value: pulumi.Input[
|
|
2372
|
+
value: pulumi.Input[_builtins.str]
|
|
2374
2373
|
"""
|
|
2375
2374
|
The tag value.
|
|
2376
2375
|
* `instanceTypes` - (Optional) The type of instances that may or may not be a part of the Ocean cluster.
|
|
@@ -2381,31 +2380,31 @@ elif False:
|
|
|
2381
2380
|
@pulumi.input_type
|
|
2382
2381
|
class OceanTagArgs:
|
|
2383
2382
|
def __init__(__self__, *,
|
|
2384
|
-
key: pulumi.Input[
|
|
2385
|
-
value: pulumi.Input[
|
|
2383
|
+
key: pulumi.Input[_builtins.str],
|
|
2384
|
+
value: pulumi.Input[_builtins.str]):
|
|
2386
2385
|
"""
|
|
2387
|
-
:param pulumi.Input[
|
|
2388
|
-
:param pulumi.Input[
|
|
2386
|
+
:param pulumi.Input[_builtins.str] key: The tag key.
|
|
2387
|
+
:param pulumi.Input[_builtins.str] value: The tag value.
|
|
2389
2388
|
* `instanceTypes` - (Optional) The type of instances that may or may not be a part of the Ocean cluster.
|
|
2390
2389
|
"""
|
|
2391
2390
|
pulumi.set(__self__, "key", key)
|
|
2392
2391
|
pulumi.set(__self__, "value", value)
|
|
2393
2392
|
|
|
2394
|
-
@property
|
|
2393
|
+
@_builtins.property
|
|
2395
2394
|
@pulumi.getter
|
|
2396
|
-
def key(self) -> pulumi.Input[
|
|
2395
|
+
def key(self) -> pulumi.Input[_builtins.str]:
|
|
2397
2396
|
"""
|
|
2398
2397
|
The tag key.
|
|
2399
2398
|
"""
|
|
2400
2399
|
return pulumi.get(self, "key")
|
|
2401
2400
|
|
|
2402
2401
|
@key.setter
|
|
2403
|
-
def key(self, value: pulumi.Input[
|
|
2402
|
+
def key(self, value: pulumi.Input[_builtins.str]):
|
|
2404
2403
|
pulumi.set(self, "key", value)
|
|
2405
2404
|
|
|
2406
|
-
@property
|
|
2405
|
+
@_builtins.property
|
|
2407
2406
|
@pulumi.getter
|
|
2408
|
-
def value(self) -> pulumi.Input[
|
|
2407
|
+
def value(self) -> pulumi.Input[_builtins.str]:
|
|
2409
2408
|
"""
|
|
2410
2409
|
The tag value.
|
|
2411
2410
|
* `instanceTypes` - (Optional) The type of instances that may or may not be a part of the Ocean cluster.
|
|
@@ -2413,21 +2412,21 @@ class OceanTagArgs:
|
|
|
2413
2412
|
return pulumi.get(self, "value")
|
|
2414
2413
|
|
|
2415
2414
|
@value.setter
|
|
2416
|
-
def value(self, value: pulumi.Input[
|
|
2415
|
+
def value(self, value: pulumi.Input[_builtins.str]):
|
|
2417
2416
|
pulumi.set(self, "value", value)
|
|
2418
2417
|
|
|
2419
2418
|
|
|
2420
2419
|
if not MYPY:
|
|
2421
2420
|
class OceanUpdatePolicyArgsDict(TypedDict):
|
|
2422
|
-
should_roll: pulumi.Input[
|
|
2421
|
+
should_roll: pulumi.Input[_builtins.bool]
|
|
2423
2422
|
"""
|
|
2424
2423
|
Enables the roll.
|
|
2425
2424
|
"""
|
|
2426
|
-
auto_apply_tags: NotRequired[pulumi.Input[
|
|
2425
|
+
auto_apply_tags: NotRequired[pulumi.Input[_builtins.bool]]
|
|
2427
2426
|
"""
|
|
2428
2427
|
will update instance tags on the fly without rolling the cluster.
|
|
2429
2428
|
"""
|
|
2430
|
-
conditioned_roll: NotRequired[pulumi.Input[
|
|
2429
|
+
conditioned_roll: NotRequired[pulumi.Input[_builtins.bool]]
|
|
2431
2430
|
"""
|
|
2432
2431
|
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).
|
|
2433
2432
|
"""
|
|
@@ -2438,14 +2437,14 @@ elif False:
|
|
|
2438
2437
|
@pulumi.input_type
|
|
2439
2438
|
class OceanUpdatePolicyArgs:
|
|
2440
2439
|
def __init__(__self__, *,
|
|
2441
|
-
should_roll: pulumi.Input[
|
|
2442
|
-
auto_apply_tags: Optional[pulumi.Input[
|
|
2443
|
-
conditioned_roll: Optional[pulumi.Input[
|
|
2440
|
+
should_roll: pulumi.Input[_builtins.bool],
|
|
2441
|
+
auto_apply_tags: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
2442
|
+
conditioned_roll: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
2444
2443
|
roll_config: Optional[pulumi.Input['OceanUpdatePolicyRollConfigArgs']] = None):
|
|
2445
2444
|
"""
|
|
2446
|
-
:param pulumi.Input[
|
|
2447
|
-
:param pulumi.Input[
|
|
2448
|
-
:param pulumi.Input[
|
|
2445
|
+
:param pulumi.Input[_builtins.bool] should_roll: Enables the roll.
|
|
2446
|
+
:param pulumi.Input[_builtins.bool] auto_apply_tags: will update instance tags on the fly without rolling the cluster.
|
|
2447
|
+
: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).
|
|
2449
2448
|
"""
|
|
2450
2449
|
pulumi.set(__self__, "should_roll", should_roll)
|
|
2451
2450
|
if auto_apply_tags is not None:
|
|
@@ -2455,43 +2454,43 @@ class OceanUpdatePolicyArgs:
|
|
|
2455
2454
|
if roll_config is not None:
|
|
2456
2455
|
pulumi.set(__self__, "roll_config", roll_config)
|
|
2457
2456
|
|
|
2458
|
-
@property
|
|
2457
|
+
@_builtins.property
|
|
2459
2458
|
@pulumi.getter(name="shouldRoll")
|
|
2460
|
-
def should_roll(self) -> pulumi.Input[
|
|
2459
|
+
def should_roll(self) -> pulumi.Input[_builtins.bool]:
|
|
2461
2460
|
"""
|
|
2462
2461
|
Enables the roll.
|
|
2463
2462
|
"""
|
|
2464
2463
|
return pulumi.get(self, "should_roll")
|
|
2465
2464
|
|
|
2466
2465
|
@should_roll.setter
|
|
2467
|
-
def should_roll(self, value: pulumi.Input[
|
|
2466
|
+
def should_roll(self, value: pulumi.Input[_builtins.bool]):
|
|
2468
2467
|
pulumi.set(self, "should_roll", value)
|
|
2469
2468
|
|
|
2470
|
-
@property
|
|
2469
|
+
@_builtins.property
|
|
2471
2470
|
@pulumi.getter(name="autoApplyTags")
|
|
2472
|
-
def auto_apply_tags(self) -> Optional[pulumi.Input[
|
|
2471
|
+
def auto_apply_tags(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
2473
2472
|
"""
|
|
2474
2473
|
will update instance tags on the fly without rolling the cluster.
|
|
2475
2474
|
"""
|
|
2476
2475
|
return pulumi.get(self, "auto_apply_tags")
|
|
2477
2476
|
|
|
2478
2477
|
@auto_apply_tags.setter
|
|
2479
|
-
def auto_apply_tags(self, value: Optional[pulumi.Input[
|
|
2478
|
+
def auto_apply_tags(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
2480
2479
|
pulumi.set(self, "auto_apply_tags", value)
|
|
2481
2480
|
|
|
2482
|
-
@property
|
|
2481
|
+
@_builtins.property
|
|
2483
2482
|
@pulumi.getter(name="conditionedRoll")
|
|
2484
|
-
def conditioned_roll(self) -> Optional[pulumi.Input[
|
|
2483
|
+
def conditioned_roll(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
2485
2484
|
"""
|
|
2486
2485
|
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).
|
|
2487
2486
|
"""
|
|
2488
2487
|
return pulumi.get(self, "conditioned_roll")
|
|
2489
2488
|
|
|
2490
2489
|
@conditioned_roll.setter
|
|
2491
|
-
def conditioned_roll(self, value: Optional[pulumi.Input[
|
|
2490
|
+
def conditioned_roll(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
2492
2491
|
pulumi.set(self, "conditioned_roll", value)
|
|
2493
2492
|
|
|
2494
|
-
@property
|
|
2493
|
+
@_builtins.property
|
|
2495
2494
|
@pulumi.getter(name="rollConfig")
|
|
2496
2495
|
def roll_config(self) -> Optional[pulumi.Input['OceanUpdatePolicyRollConfigArgs']]:
|
|
2497
2496
|
return pulumi.get(self, "roll_config")
|
|
@@ -2503,11 +2502,11 @@ class OceanUpdatePolicyArgs:
|
|
|
2503
2502
|
|
|
2504
2503
|
if not MYPY:
|
|
2505
2504
|
class OceanUpdatePolicyRollConfigArgsDict(TypedDict):
|
|
2506
|
-
batch_size_percentage: pulumi.Input[
|
|
2505
|
+
batch_size_percentage: pulumi.Input[_builtins.int]
|
|
2507
2506
|
"""
|
|
2508
2507
|
Sets the percentage of the instances to deploy in each batch.
|
|
2509
2508
|
"""
|
|
2510
|
-
batch_min_healthy_percentage: NotRequired[pulumi.Input[
|
|
2509
|
+
batch_min_healthy_percentage: NotRequired[pulumi.Input[_builtins.int]]
|
|
2511
2510
|
"""
|
|
2512
2511
|
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.
|
|
2513
2512
|
"""
|
|
@@ -2517,38 +2516,38 @@ elif False:
|
|
|
2517
2516
|
@pulumi.input_type
|
|
2518
2517
|
class OceanUpdatePolicyRollConfigArgs:
|
|
2519
2518
|
def __init__(__self__, *,
|
|
2520
|
-
batch_size_percentage: pulumi.Input[
|
|
2521
|
-
batch_min_healthy_percentage: Optional[pulumi.Input[
|
|
2519
|
+
batch_size_percentage: pulumi.Input[_builtins.int],
|
|
2520
|
+
batch_min_healthy_percentage: Optional[pulumi.Input[_builtins.int]] = None):
|
|
2522
2521
|
"""
|
|
2523
|
-
:param pulumi.Input[
|
|
2524
|
-
:param pulumi.Input[
|
|
2522
|
+
:param pulumi.Input[_builtins.int] batch_size_percentage: Sets the percentage of the instances to deploy in each batch.
|
|
2523
|
+
: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.
|
|
2525
2524
|
"""
|
|
2526
2525
|
pulumi.set(__self__, "batch_size_percentage", batch_size_percentage)
|
|
2527
2526
|
if batch_min_healthy_percentage is not None:
|
|
2528
2527
|
pulumi.set(__self__, "batch_min_healthy_percentage", batch_min_healthy_percentage)
|
|
2529
2528
|
|
|
2530
|
-
@property
|
|
2529
|
+
@_builtins.property
|
|
2531
2530
|
@pulumi.getter(name="batchSizePercentage")
|
|
2532
|
-
def batch_size_percentage(self) -> pulumi.Input[
|
|
2531
|
+
def batch_size_percentage(self) -> pulumi.Input[_builtins.int]:
|
|
2533
2532
|
"""
|
|
2534
2533
|
Sets the percentage of the instances to deploy in each batch.
|
|
2535
2534
|
"""
|
|
2536
2535
|
return pulumi.get(self, "batch_size_percentage")
|
|
2537
2536
|
|
|
2538
2537
|
@batch_size_percentage.setter
|
|
2539
|
-
def batch_size_percentage(self, value: pulumi.Input[
|
|
2538
|
+
def batch_size_percentage(self, value: pulumi.Input[_builtins.int]):
|
|
2540
2539
|
pulumi.set(self, "batch_size_percentage", value)
|
|
2541
2540
|
|
|
2542
|
-
@property
|
|
2541
|
+
@_builtins.property
|
|
2543
2542
|
@pulumi.getter(name="batchMinHealthyPercentage")
|
|
2544
|
-
def batch_min_healthy_percentage(self) -> Optional[pulumi.Input[
|
|
2543
|
+
def batch_min_healthy_percentage(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
2545
2544
|
"""
|
|
2546
2545
|
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.
|
|
2547
2546
|
"""
|
|
2548
2547
|
return pulumi.get(self, "batch_min_healthy_percentage")
|
|
2549
2548
|
|
|
2550
2549
|
@batch_min_healthy_percentage.setter
|
|
2551
|
-
def batch_min_healthy_percentage(self, value: Optional[pulumi.Input[
|
|
2550
|
+
def batch_min_healthy_percentage(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
2552
2551
|
pulumi.set(self, "batch_min_healthy_percentage", value)
|
|
2553
2552
|
|
|
2554
2553
|
|