pulumi-spotinst 3.115.0a1742873189__py3-none-any.whl → 3.128.0a1767140134__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- pulumi_spotinst/__init__.py +11 -1
- pulumi_spotinst/_inputs.py +2206 -1519
- pulumi_spotinst/_utilities.py +1 -1
- pulumi_spotinst/account.py +20 -19
- pulumi_spotinst/aws/__init__.py +2 -1
- pulumi_spotinst/aws/_inputs.py +3991 -3619
- pulumi_spotinst/aws/account.py +20 -19
- pulumi_spotinst/aws/beanstalk.py +254 -177
- pulumi_spotinst/aws/credentials.py +37 -36
- pulumi_spotinst/aws/elastigroup.py +938 -950
- pulumi_spotinst/aws/managed_instance.py +507 -506
- pulumi_spotinst/aws/mr_scalar.py +658 -653
- pulumi_spotinst/aws/ocean.py +624 -529
- pulumi_spotinst/aws/ocean_extended_resource_definition.py +37 -36
- pulumi_spotinst/aws/ocean_launch_spec.py +395 -300
- pulumi_spotinst/aws/outputs.py +2631 -2371
- pulumi_spotinst/aws/suspension.py +23 -22
- pulumi_spotinst/azure/__init__.py +2 -1
- pulumi_spotinst/azure/_inputs.py +607 -607
- pulumi_spotinst/azure/ocean_np.py +387 -386
- pulumi_spotinst/azure/ocean_np_virtual_node_group.py +323 -322
- pulumi_spotinst/azure/outputs.py +411 -411
- pulumi_spotinst/config/__init__.py +2 -1
- pulumi_spotinst/config/__init__.pyi +2 -2
- pulumi_spotinst/config/vars.py +6 -6
- pulumi_spotinst/credentials_azure.py +139 -89
- pulumi_spotinst/credentials_gcp.py +190 -189
- pulumi_spotinst/data_integration.py +40 -39
- pulumi_spotinst/ecs/__init__.py +2 -1
- pulumi_spotinst/ecs/_inputs.py +584 -584
- pulumi_spotinst/ecs/ocean.py +628 -415
- pulumi_spotinst/ecs/ocean_launch_spec.py +197 -196
- pulumi_spotinst/ecs/outputs.py +394 -394
- pulumi_spotinst/elastigroup_azure_v3.py +326 -325
- pulumi_spotinst/gcp/__init__.py +2 -1
- pulumi_spotinst/gcp/_inputs.py +573 -499
- pulumi_spotinst/gcp/elastigroup.py +491 -482
- pulumi_spotinst/gcp/outputs.py +395 -330
- pulumi_spotinst/gke/__init__.py +2 -1
- pulumi_spotinst/gke/_inputs.py +1120 -895
- pulumi_spotinst/gke/elastigroup.py +341 -340
- pulumi_spotinst/gke/ocean_import.py +204 -203
- pulumi_spotinst/gke/ocean_launch_spec.py +285 -213
- pulumi_spotinst/gke/ocean_launch_spec_import.py +37 -36
- pulumi_spotinst/gke/outputs.py +769 -583
- pulumi_spotinst/health_check.py +106 -65
- pulumi_spotinst/notification_center.py +344 -0
- pulumi_spotinst/ocean_right_sizing_rule.py +424 -77
- pulumi_spotinst/oceancd/__init__.py +2 -1
- pulumi_spotinst/oceancd/_inputs.py +764 -764
- pulumi_spotinst/oceancd/outputs.py +526 -526
- pulumi_spotinst/oceancd/rollout_spec.py +35 -34
- pulumi_spotinst/oceancd/strategy.py +22 -21
- pulumi_spotinst/oceancd/verification_provider.py +52 -51
- pulumi_spotinst/oceancd/verification_template.py +26 -25
- pulumi_spotinst/organization/__init__.py +2 -1
- pulumi_spotinst/organization/_inputs.py +68 -68
- pulumi_spotinst/organization/outputs.py +46 -46
- pulumi_spotinst/organization/policy.py +40 -39
- pulumi_spotinst/organization/programmatic_user.py +60 -59
- pulumi_spotinst/organization/user.py +108 -107
- pulumi_spotinst/organization/user_group.py +57 -56
- pulumi_spotinst/outputs.py +1472 -932
- pulumi_spotinst/provider.py +61 -40
- pulumi_spotinst/pulumi-plugin.json +1 -1
- pulumi_spotinst/spark/__init__.py +2 -1
- pulumi_spotinst/spark/_inputs.py +104 -104
- pulumi_spotinst/spark/ocean.py +38 -37
- pulumi_spotinst/spark/ocean_virtual_node_group.py +29 -28
- pulumi_spotinst/spark/outputs.py +72 -72
- pulumi_spotinst/stateful_node_azure.py +318 -343
- pulumi_spotinst/subscription.py +88 -87
- {pulumi_spotinst-3.115.0a1742873189.dist-info → pulumi_spotinst-3.128.0a1767140134.dist-info}/METADATA +3 -3
- pulumi_spotinst-3.128.0a1767140134.dist-info/RECORD +77 -0
- {pulumi_spotinst-3.115.0a1742873189.dist-info → pulumi_spotinst-3.128.0a1767140134.dist-info}/WHEEL +1 -1
- pulumi_spotinst-3.115.0a1742873189.dist-info/RECORD +0 -76
- {pulumi_spotinst-3.115.0a1742873189.dist-info → pulumi_spotinst-3.128.0a1767140134.dist-info}/top_level.txt +0 -0
pulumi_spotinst/gcp/_inputs.py
CHANGED
|
@@ -1,8 +1,8 @@
|
|
|
1
1
|
# coding=utf-8
|
|
2
|
-
# *** WARNING: this file was generated by
|
|
2
|
+
# *** WARNING: this file was generated by pulumi-language-python. ***
|
|
3
3
|
# *** Do not edit by hand unless you're certain you know what you are doing! ***
|
|
4
4
|
|
|
5
|
-
import
|
|
5
|
+
import builtins as _builtins
|
|
6
6
|
import warnings
|
|
7
7
|
import sys
|
|
8
8
|
import pulumi
|
|
@@ -17,6 +17,8 @@ from .. import _utilities
|
|
|
17
17
|
__all__ = [
|
|
18
18
|
'ElastigroupBackendServiceArgs',
|
|
19
19
|
'ElastigroupBackendServiceArgsDict',
|
|
20
|
+
'ElastigroupBackendServiceBackendBalancingArgs',
|
|
21
|
+
'ElastigroupBackendServiceBackendBalancingArgsDict',
|
|
20
22
|
'ElastigroupBackendServiceNamedPortArgs',
|
|
21
23
|
'ElastigroupBackendServiceNamedPortArgsDict',
|
|
22
24
|
'ElastigroupDiskArgs',
|
|
@@ -69,11 +71,15 @@ MYPY = False
|
|
|
69
71
|
|
|
70
72
|
if not MYPY:
|
|
71
73
|
class ElastigroupBackendServiceArgsDict(TypedDict):
|
|
72
|
-
service_name: pulumi.Input[str]
|
|
74
|
+
service_name: pulumi.Input[_builtins.str]
|
|
73
75
|
"""
|
|
74
76
|
The name of the backend service.
|
|
75
77
|
"""
|
|
76
|
-
|
|
78
|
+
backend_balancing: NotRequired[pulumi.Input['ElastigroupBackendServiceBackendBalancingArgsDict']]
|
|
79
|
+
"""
|
|
80
|
+
Configure how traffic is distributed across instance groups.
|
|
81
|
+
"""
|
|
82
|
+
location_type: NotRequired[pulumi.Input[_builtins.str]]
|
|
77
83
|
"""
|
|
78
84
|
Sets which location the backend services will be active. Valid values: `regional`, `global`.
|
|
79
85
|
"""
|
|
@@ -81,7 +87,7 @@ if not MYPY:
|
|
|
81
87
|
"""
|
|
82
88
|
Describes a named port and a list of ports.
|
|
83
89
|
"""
|
|
84
|
-
scheme: NotRequired[pulumi.Input[str]]
|
|
90
|
+
scheme: NotRequired[pulumi.Input[_builtins.str]]
|
|
85
91
|
"""
|
|
86
92
|
Use when `location_type` is "regional". Set the traffic for the backend service to either between the instances in the vpc or to traffic from the internet. Valid values: `INTERNAL`, `EXTERNAL`.
|
|
87
93
|
"""
|
|
@@ -91,17 +97,21 @@ elif False:
|
|
|
91
97
|
@pulumi.input_type
|
|
92
98
|
class ElastigroupBackendServiceArgs:
|
|
93
99
|
def __init__(__self__, *,
|
|
94
|
-
service_name: pulumi.Input[str],
|
|
95
|
-
|
|
100
|
+
service_name: pulumi.Input[_builtins.str],
|
|
101
|
+
backend_balancing: Optional[pulumi.Input['ElastigroupBackendServiceBackendBalancingArgs']] = None,
|
|
102
|
+
location_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
96
103
|
named_ports: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupBackendServiceNamedPortArgs']]]] = None,
|
|
97
|
-
scheme: Optional[pulumi.Input[str]] = None):
|
|
104
|
+
scheme: Optional[pulumi.Input[_builtins.str]] = None):
|
|
98
105
|
"""
|
|
99
|
-
:param pulumi.Input[str] service_name: The name of the backend service.
|
|
100
|
-
:param pulumi.Input[
|
|
106
|
+
:param pulumi.Input[_builtins.str] service_name: The name of the backend service.
|
|
107
|
+
:param pulumi.Input['ElastigroupBackendServiceBackendBalancingArgs'] backend_balancing: Configure how traffic is distributed across instance groups.
|
|
108
|
+
:param pulumi.Input[_builtins.str] location_type: Sets which location the backend services will be active. Valid values: `regional`, `global`.
|
|
101
109
|
:param pulumi.Input[Sequence[pulumi.Input['ElastigroupBackendServiceNamedPortArgs']]] named_ports: Describes a named port and a list of ports.
|
|
102
|
-
:param pulumi.Input[str] scheme: Use when `location_type` is "regional". Set the traffic for the backend service to either between the instances in the vpc or to traffic from the internet. Valid values: `INTERNAL`, `EXTERNAL`.
|
|
110
|
+
:param pulumi.Input[_builtins.str] scheme: Use when `location_type` is "regional". Set the traffic for the backend service to either between the instances in the vpc or to traffic from the internet. Valid values: `INTERNAL`, `EXTERNAL`.
|
|
103
111
|
"""
|
|
104
112
|
pulumi.set(__self__, "service_name", service_name)
|
|
113
|
+
if backend_balancing is not None:
|
|
114
|
+
pulumi.set(__self__, "backend_balancing", backend_balancing)
|
|
105
115
|
if location_type is not None:
|
|
106
116
|
pulumi.set(__self__, "location_type", location_type)
|
|
107
117
|
if named_ports is not None:
|
|
@@ -109,31 +119,43 @@ class ElastigroupBackendServiceArgs:
|
|
|
109
119
|
if scheme is not None:
|
|
110
120
|
pulumi.set(__self__, "scheme", scheme)
|
|
111
121
|
|
|
112
|
-
@property
|
|
122
|
+
@_builtins.property
|
|
113
123
|
@pulumi.getter(name="serviceName")
|
|
114
|
-
def service_name(self) -> pulumi.Input[str]:
|
|
124
|
+
def service_name(self) -> pulumi.Input[_builtins.str]:
|
|
115
125
|
"""
|
|
116
126
|
The name of the backend service.
|
|
117
127
|
"""
|
|
118
128
|
return pulumi.get(self, "service_name")
|
|
119
129
|
|
|
120
130
|
@service_name.setter
|
|
121
|
-
def service_name(self, value: pulumi.Input[str]):
|
|
131
|
+
def service_name(self, value: pulumi.Input[_builtins.str]):
|
|
122
132
|
pulumi.set(self, "service_name", value)
|
|
123
133
|
|
|
124
|
-
@property
|
|
134
|
+
@_builtins.property
|
|
135
|
+
@pulumi.getter(name="backendBalancing")
|
|
136
|
+
def backend_balancing(self) -> Optional[pulumi.Input['ElastigroupBackendServiceBackendBalancingArgs']]:
|
|
137
|
+
"""
|
|
138
|
+
Configure how traffic is distributed across instance groups.
|
|
139
|
+
"""
|
|
140
|
+
return pulumi.get(self, "backend_balancing")
|
|
141
|
+
|
|
142
|
+
@backend_balancing.setter
|
|
143
|
+
def backend_balancing(self, value: Optional[pulumi.Input['ElastigroupBackendServiceBackendBalancingArgs']]):
|
|
144
|
+
pulumi.set(self, "backend_balancing", value)
|
|
145
|
+
|
|
146
|
+
@_builtins.property
|
|
125
147
|
@pulumi.getter(name="locationType")
|
|
126
|
-
def location_type(self) -> Optional[pulumi.Input[str]]:
|
|
148
|
+
def location_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
127
149
|
"""
|
|
128
150
|
Sets which location the backend services will be active. Valid values: `regional`, `global`.
|
|
129
151
|
"""
|
|
130
152
|
return pulumi.get(self, "location_type")
|
|
131
153
|
|
|
132
154
|
@location_type.setter
|
|
133
|
-
def location_type(self, value: Optional[pulumi.Input[str]]):
|
|
155
|
+
def location_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
134
156
|
pulumi.set(self, "location_type", value)
|
|
135
157
|
|
|
136
|
-
@property
|
|
158
|
+
@_builtins.property
|
|
137
159
|
@pulumi.getter(name="namedPorts")
|
|
138
160
|
def named_ports(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupBackendServiceNamedPortArgs']]]]:
|
|
139
161
|
"""
|
|
@@ -145,30 +167,86 @@ class ElastigroupBackendServiceArgs:
|
|
|
145
167
|
def named_ports(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupBackendServiceNamedPortArgs']]]]):
|
|
146
168
|
pulumi.set(self, "named_ports", value)
|
|
147
169
|
|
|
148
|
-
@property
|
|
170
|
+
@_builtins.property
|
|
149
171
|
@pulumi.getter
|
|
150
|
-
def scheme(self) -> Optional[pulumi.Input[str]]:
|
|
172
|
+
def scheme(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
151
173
|
"""
|
|
152
174
|
Use when `location_type` is "regional". Set the traffic for the backend service to either between the instances in the vpc or to traffic from the internet. Valid values: `INTERNAL`, `EXTERNAL`.
|
|
153
175
|
"""
|
|
154
176
|
return pulumi.get(self, "scheme")
|
|
155
177
|
|
|
156
178
|
@scheme.setter
|
|
157
|
-
def scheme(self, value: Optional[pulumi.Input[str]]):
|
|
179
|
+
def scheme(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
158
180
|
pulumi.set(self, "scheme", value)
|
|
159
181
|
|
|
160
182
|
|
|
183
|
+
if not MYPY:
|
|
184
|
+
class ElastigroupBackendServiceBackendBalancingArgsDict(TypedDict):
|
|
185
|
+
backend_balancing_mode: NotRequired[pulumi.Input[_builtins.str]]
|
|
186
|
+
"""
|
|
187
|
+
The backend balancing mode. Valid values: `RATE`, `UTILIZATION`.
|
|
188
|
+
"""
|
|
189
|
+
max_rate_per_instance: NotRequired[pulumi.Input[_builtins.int]]
|
|
190
|
+
"""
|
|
191
|
+
If the backendBalancingMode is set to RATE, this field is required.
|
|
192
|
+
|
|
193
|
+
Usage:
|
|
194
|
+
"""
|
|
195
|
+
elif False:
|
|
196
|
+
ElastigroupBackendServiceBackendBalancingArgsDict: TypeAlias = Mapping[str, Any]
|
|
197
|
+
|
|
198
|
+
@pulumi.input_type
|
|
199
|
+
class ElastigroupBackendServiceBackendBalancingArgs:
|
|
200
|
+
def __init__(__self__, *,
|
|
201
|
+
backend_balancing_mode: Optional[pulumi.Input[_builtins.str]] = None,
|
|
202
|
+
max_rate_per_instance: Optional[pulumi.Input[_builtins.int]] = None):
|
|
203
|
+
"""
|
|
204
|
+
:param pulumi.Input[_builtins.str] backend_balancing_mode: The backend balancing mode. Valid values: `RATE`, `UTILIZATION`.
|
|
205
|
+
:param pulumi.Input[_builtins.int] max_rate_per_instance: If the backendBalancingMode is set to RATE, this field is required.
|
|
206
|
+
|
|
207
|
+
Usage:
|
|
208
|
+
"""
|
|
209
|
+
if backend_balancing_mode is not None:
|
|
210
|
+
pulumi.set(__self__, "backend_balancing_mode", backend_balancing_mode)
|
|
211
|
+
if max_rate_per_instance is not None:
|
|
212
|
+
pulumi.set(__self__, "max_rate_per_instance", max_rate_per_instance)
|
|
213
|
+
|
|
214
|
+
@_builtins.property
|
|
215
|
+
@pulumi.getter(name="backendBalancingMode")
|
|
216
|
+
def backend_balancing_mode(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
217
|
+
"""
|
|
218
|
+
The backend balancing mode. Valid values: `RATE`, `UTILIZATION`.
|
|
219
|
+
"""
|
|
220
|
+
return pulumi.get(self, "backend_balancing_mode")
|
|
221
|
+
|
|
222
|
+
@backend_balancing_mode.setter
|
|
223
|
+
def backend_balancing_mode(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
224
|
+
pulumi.set(self, "backend_balancing_mode", value)
|
|
225
|
+
|
|
226
|
+
@_builtins.property
|
|
227
|
+
@pulumi.getter(name="maxRatePerInstance")
|
|
228
|
+
def max_rate_per_instance(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
229
|
+
"""
|
|
230
|
+
If the backendBalancingMode is set to RATE, this field is required.
|
|
231
|
+
|
|
232
|
+
Usage:
|
|
233
|
+
"""
|
|
234
|
+
return pulumi.get(self, "max_rate_per_instance")
|
|
235
|
+
|
|
236
|
+
@max_rate_per_instance.setter
|
|
237
|
+
def max_rate_per_instance(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
238
|
+
pulumi.set(self, "max_rate_per_instance", value)
|
|
239
|
+
|
|
240
|
+
|
|
161
241
|
if not MYPY:
|
|
162
242
|
class ElastigroupBackendServiceNamedPortArgsDict(TypedDict):
|
|
163
|
-
name: pulumi.Input[str]
|
|
243
|
+
name: pulumi.Input[_builtins.str]
|
|
164
244
|
"""
|
|
165
245
|
The name of the port.
|
|
166
246
|
"""
|
|
167
|
-
ports: pulumi.Input[Sequence[pulumi.Input[str]]]
|
|
247
|
+
ports: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]
|
|
168
248
|
"""
|
|
169
249
|
A list of ports.
|
|
170
|
-
|
|
171
|
-
Usage:
|
|
172
250
|
"""
|
|
173
251
|
elif False:
|
|
174
252
|
ElastigroupBackendServiceNamedPortArgsDict: TypeAlias = Mapping[str, Any]
|
|
@@ -176,55 +254,51 @@ elif False:
|
|
|
176
254
|
@pulumi.input_type
|
|
177
255
|
class ElastigroupBackendServiceNamedPortArgs:
|
|
178
256
|
def __init__(__self__, *,
|
|
179
|
-
name: pulumi.Input[str],
|
|
180
|
-
ports: pulumi.Input[Sequence[pulumi.Input[str]]]):
|
|
257
|
+
name: pulumi.Input[_builtins.str],
|
|
258
|
+
ports: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]):
|
|
181
259
|
"""
|
|
182
|
-
:param pulumi.Input[str] name: The name of the port.
|
|
183
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] ports: A list of ports.
|
|
184
|
-
|
|
185
|
-
Usage:
|
|
260
|
+
:param pulumi.Input[_builtins.str] name: The name of the port.
|
|
261
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] ports: A list of ports.
|
|
186
262
|
"""
|
|
187
263
|
pulumi.set(__self__, "name", name)
|
|
188
264
|
pulumi.set(__self__, "ports", ports)
|
|
189
265
|
|
|
190
|
-
@property
|
|
266
|
+
@_builtins.property
|
|
191
267
|
@pulumi.getter
|
|
192
|
-
def name(self) -> pulumi.Input[str]:
|
|
268
|
+
def name(self) -> pulumi.Input[_builtins.str]:
|
|
193
269
|
"""
|
|
194
270
|
The name of the port.
|
|
195
271
|
"""
|
|
196
272
|
return pulumi.get(self, "name")
|
|
197
273
|
|
|
198
274
|
@name.setter
|
|
199
|
-
def name(self, value: pulumi.Input[str]):
|
|
275
|
+
def name(self, value: pulumi.Input[_builtins.str]):
|
|
200
276
|
pulumi.set(self, "name", value)
|
|
201
277
|
|
|
202
|
-
@property
|
|
278
|
+
@_builtins.property
|
|
203
279
|
@pulumi.getter
|
|
204
|
-
def ports(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
|
|
280
|
+
def ports(self) -> pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]:
|
|
205
281
|
"""
|
|
206
282
|
A list of ports.
|
|
207
|
-
|
|
208
|
-
Usage:
|
|
209
283
|
"""
|
|
210
284
|
return pulumi.get(self, "ports")
|
|
211
285
|
|
|
212
286
|
@ports.setter
|
|
213
|
-
def ports(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
|
|
287
|
+
def ports(self, value: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]):
|
|
214
288
|
pulumi.set(self, "ports", value)
|
|
215
289
|
|
|
216
290
|
|
|
217
291
|
if not MYPY:
|
|
218
292
|
class ElastigroupDiskArgsDict(TypedDict):
|
|
219
|
-
auto_delete: NotRequired[pulumi.Input[bool]]
|
|
293
|
+
auto_delete: NotRequired[pulumi.Input[_builtins.bool]]
|
|
220
294
|
"""
|
|
221
295
|
Specifies whether the disk will be auto-deleted when the instance is deleted.
|
|
222
296
|
"""
|
|
223
|
-
boot: NotRequired[pulumi.Input[bool]]
|
|
297
|
+
boot: NotRequired[pulumi.Input[_builtins.bool]]
|
|
224
298
|
"""
|
|
225
299
|
Indicates that this is a boot disk. The virtual machine will use the first partition of the disk for its root filesystem.
|
|
226
300
|
"""
|
|
227
|
-
device_name: NotRequired[pulumi.Input[str]]
|
|
301
|
+
device_name: NotRequired[pulumi.Input[_builtins.str]]
|
|
228
302
|
"""
|
|
229
303
|
Specifies a unique device name of your choice.
|
|
230
304
|
"""
|
|
@@ -232,19 +306,19 @@ if not MYPY:
|
|
|
232
306
|
"""
|
|
233
307
|
Specifies the parameters for a new disk that will be created alongside the new instance. Use initialization parameters to create boot disks or local SSDs attached to the new instance.
|
|
234
308
|
"""
|
|
235
|
-
interface: NotRequired[pulumi.Input[str]]
|
|
309
|
+
interface: NotRequired[pulumi.Input[_builtins.str]]
|
|
236
310
|
"""
|
|
237
311
|
Specifies the disk interface to use for attaching this disk, which is either SCSI or NVME.
|
|
238
312
|
"""
|
|
239
|
-
mode: NotRequired[pulumi.Input[str]]
|
|
313
|
+
mode: NotRequired[pulumi.Input[_builtins.str]]
|
|
240
314
|
"""
|
|
241
315
|
The mode in which to attach this disk, either READ_WRITE or READ_ONLY.
|
|
242
316
|
"""
|
|
243
|
-
source: NotRequired[pulumi.Input[str]]
|
|
317
|
+
source: NotRequired[pulumi.Input[_builtins.str]]
|
|
244
318
|
"""
|
|
245
319
|
Specifies a valid partial or full URL to an existing Persistent Disk resource. This field is only applicable for persistent disks.
|
|
246
320
|
"""
|
|
247
|
-
type: NotRequired[pulumi.Input[str]]
|
|
321
|
+
type: NotRequired[pulumi.Input[_builtins.str]]
|
|
248
322
|
"""
|
|
249
323
|
Specifies the type of disk, either SCRATCH or PERSISTENT.
|
|
250
324
|
"""
|
|
@@ -254,23 +328,23 @@ elif False:
|
|
|
254
328
|
@pulumi.input_type
|
|
255
329
|
class ElastigroupDiskArgs:
|
|
256
330
|
def __init__(__self__, *,
|
|
257
|
-
auto_delete: Optional[pulumi.Input[bool]] = None,
|
|
258
|
-
boot: Optional[pulumi.Input[bool]] = None,
|
|
259
|
-
device_name: Optional[pulumi.Input[str]] = None,
|
|
331
|
+
auto_delete: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
332
|
+
boot: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
333
|
+
device_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
260
334
|
initialize_params: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupDiskInitializeParamArgs']]]] = None,
|
|
261
|
-
interface: Optional[pulumi.Input[str]] = None,
|
|
262
|
-
mode: Optional[pulumi.Input[str]] = None,
|
|
263
|
-
source: Optional[pulumi.Input[str]] = None,
|
|
264
|
-
type: Optional[pulumi.Input[str]] = None):
|
|
265
|
-
"""
|
|
266
|
-
:param pulumi.Input[bool] auto_delete: Specifies whether the disk will be auto-deleted when the instance is deleted.
|
|
267
|
-
:param pulumi.Input[bool] boot: Indicates that this is a boot disk. The virtual machine will use the first partition of the disk for its root filesystem.
|
|
268
|
-
:param pulumi.Input[str] device_name: Specifies a unique device name of your choice.
|
|
335
|
+
interface: Optional[pulumi.Input[_builtins.str]] = None,
|
|
336
|
+
mode: Optional[pulumi.Input[_builtins.str]] = None,
|
|
337
|
+
source: Optional[pulumi.Input[_builtins.str]] = None,
|
|
338
|
+
type: Optional[pulumi.Input[_builtins.str]] = None):
|
|
339
|
+
"""
|
|
340
|
+
:param pulumi.Input[_builtins.bool] auto_delete: Specifies whether the disk will be auto-deleted when the instance is deleted.
|
|
341
|
+
:param pulumi.Input[_builtins.bool] boot: Indicates that this is a boot disk. The virtual machine will use the first partition of the disk for its root filesystem.
|
|
342
|
+
:param pulumi.Input[_builtins.str] device_name: Specifies a unique device name of your choice.
|
|
269
343
|
:param pulumi.Input[Sequence[pulumi.Input['ElastigroupDiskInitializeParamArgs']]] initialize_params: Specifies the parameters for a new disk that will be created alongside the new instance. Use initialization parameters to create boot disks or local SSDs attached to the new instance.
|
|
270
|
-
:param pulumi.Input[str] interface: Specifies the disk interface to use for attaching this disk, which is either SCSI or NVME.
|
|
271
|
-
:param pulumi.Input[str] mode: The mode in which to attach this disk, either READ_WRITE or READ_ONLY.
|
|
272
|
-
:param pulumi.Input[str] source: Specifies a valid partial or full URL to an existing Persistent Disk resource. This field is only applicable for persistent disks.
|
|
273
|
-
:param pulumi.Input[str] type: Specifies the type of disk, either SCRATCH or PERSISTENT.
|
|
344
|
+
:param pulumi.Input[_builtins.str] interface: Specifies the disk interface to use for attaching this disk, which is either SCSI or NVME.
|
|
345
|
+
:param pulumi.Input[_builtins.str] mode: The mode in which to attach this disk, either READ_WRITE or READ_ONLY.
|
|
346
|
+
:param pulumi.Input[_builtins.str] source: Specifies a valid partial or full URL to an existing Persistent Disk resource. This field is only applicable for persistent disks.
|
|
347
|
+
:param pulumi.Input[_builtins.str] type: Specifies the type of disk, either SCRATCH or PERSISTENT.
|
|
274
348
|
"""
|
|
275
349
|
if auto_delete is not None:
|
|
276
350
|
pulumi.set(__self__, "auto_delete", auto_delete)
|
|
@@ -289,43 +363,43 @@ class ElastigroupDiskArgs:
|
|
|
289
363
|
if type is not None:
|
|
290
364
|
pulumi.set(__self__, "type", type)
|
|
291
365
|
|
|
292
|
-
@property
|
|
366
|
+
@_builtins.property
|
|
293
367
|
@pulumi.getter(name="autoDelete")
|
|
294
|
-
def auto_delete(self) -> Optional[pulumi.Input[bool]]:
|
|
368
|
+
def auto_delete(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
295
369
|
"""
|
|
296
370
|
Specifies whether the disk will be auto-deleted when the instance is deleted.
|
|
297
371
|
"""
|
|
298
372
|
return pulumi.get(self, "auto_delete")
|
|
299
373
|
|
|
300
374
|
@auto_delete.setter
|
|
301
|
-
def auto_delete(self, value: Optional[pulumi.Input[bool]]):
|
|
375
|
+
def auto_delete(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
302
376
|
pulumi.set(self, "auto_delete", value)
|
|
303
377
|
|
|
304
|
-
@property
|
|
378
|
+
@_builtins.property
|
|
305
379
|
@pulumi.getter
|
|
306
|
-
def boot(self) -> Optional[pulumi.Input[bool]]:
|
|
380
|
+
def boot(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
307
381
|
"""
|
|
308
382
|
Indicates that this is a boot disk. The virtual machine will use the first partition of the disk for its root filesystem.
|
|
309
383
|
"""
|
|
310
384
|
return pulumi.get(self, "boot")
|
|
311
385
|
|
|
312
386
|
@boot.setter
|
|
313
|
-
def boot(self, value: Optional[pulumi.Input[bool]]):
|
|
387
|
+
def boot(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
314
388
|
pulumi.set(self, "boot", value)
|
|
315
389
|
|
|
316
|
-
@property
|
|
390
|
+
@_builtins.property
|
|
317
391
|
@pulumi.getter(name="deviceName")
|
|
318
|
-
def device_name(self) -> Optional[pulumi.Input[str]]:
|
|
392
|
+
def device_name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
319
393
|
"""
|
|
320
394
|
Specifies a unique device name of your choice.
|
|
321
395
|
"""
|
|
322
396
|
return pulumi.get(self, "device_name")
|
|
323
397
|
|
|
324
398
|
@device_name.setter
|
|
325
|
-
def device_name(self, value: Optional[pulumi.Input[str]]):
|
|
399
|
+
def device_name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
326
400
|
pulumi.set(self, "device_name", value)
|
|
327
401
|
|
|
328
|
-
@property
|
|
402
|
+
@_builtins.property
|
|
329
403
|
@pulumi.getter(name="initializeParams")
|
|
330
404
|
def initialize_params(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupDiskInitializeParamArgs']]]]:
|
|
331
405
|
"""
|
|
@@ -337,68 +411,68 @@ class ElastigroupDiskArgs:
|
|
|
337
411
|
def initialize_params(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupDiskInitializeParamArgs']]]]):
|
|
338
412
|
pulumi.set(self, "initialize_params", value)
|
|
339
413
|
|
|
340
|
-
@property
|
|
414
|
+
@_builtins.property
|
|
341
415
|
@pulumi.getter
|
|
342
|
-
def interface(self) -> Optional[pulumi.Input[str]]:
|
|
416
|
+
def interface(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
343
417
|
"""
|
|
344
418
|
Specifies the disk interface to use for attaching this disk, which is either SCSI or NVME.
|
|
345
419
|
"""
|
|
346
420
|
return pulumi.get(self, "interface")
|
|
347
421
|
|
|
348
422
|
@interface.setter
|
|
349
|
-
def interface(self, value: Optional[pulumi.Input[str]]):
|
|
423
|
+
def interface(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
350
424
|
pulumi.set(self, "interface", value)
|
|
351
425
|
|
|
352
|
-
@property
|
|
426
|
+
@_builtins.property
|
|
353
427
|
@pulumi.getter
|
|
354
|
-
def mode(self) -> Optional[pulumi.Input[str]]:
|
|
428
|
+
def mode(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
355
429
|
"""
|
|
356
430
|
The mode in which to attach this disk, either READ_WRITE or READ_ONLY.
|
|
357
431
|
"""
|
|
358
432
|
return pulumi.get(self, "mode")
|
|
359
433
|
|
|
360
434
|
@mode.setter
|
|
361
|
-
def mode(self, value: Optional[pulumi.Input[str]]):
|
|
435
|
+
def mode(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
362
436
|
pulumi.set(self, "mode", value)
|
|
363
437
|
|
|
364
|
-
@property
|
|
438
|
+
@_builtins.property
|
|
365
439
|
@pulumi.getter
|
|
366
|
-
def source(self) -> Optional[pulumi.Input[str]]:
|
|
440
|
+
def source(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
367
441
|
"""
|
|
368
442
|
Specifies a valid partial or full URL to an existing Persistent Disk resource. This field is only applicable for persistent disks.
|
|
369
443
|
"""
|
|
370
444
|
return pulumi.get(self, "source")
|
|
371
445
|
|
|
372
446
|
@source.setter
|
|
373
|
-
def source(self, value: Optional[pulumi.Input[str]]):
|
|
447
|
+
def source(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
374
448
|
pulumi.set(self, "source", value)
|
|
375
449
|
|
|
376
|
-
@property
|
|
450
|
+
@_builtins.property
|
|
377
451
|
@pulumi.getter
|
|
378
|
-
def type(self) -> Optional[pulumi.Input[str]]:
|
|
452
|
+
def type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
379
453
|
"""
|
|
380
454
|
Specifies the type of disk, either SCRATCH or PERSISTENT.
|
|
381
455
|
"""
|
|
382
456
|
return pulumi.get(self, "type")
|
|
383
457
|
|
|
384
458
|
@type.setter
|
|
385
|
-
def type(self, value: Optional[pulumi.Input[str]]):
|
|
459
|
+
def type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
386
460
|
pulumi.set(self, "type", value)
|
|
387
461
|
|
|
388
462
|
|
|
389
463
|
if not MYPY:
|
|
390
464
|
class ElastigroupDiskInitializeParamArgsDict(TypedDict):
|
|
391
|
-
source_image: pulumi.Input[str]
|
|
465
|
+
source_image: pulumi.Input[_builtins.str]
|
|
392
466
|
"""
|
|
393
467
|
A source image used to create the disk. You can provide a private (custom) image, and Compute Engine will use the corresponding image from your project.
|
|
394
468
|
|
|
395
469
|
Usage:
|
|
396
470
|
"""
|
|
397
|
-
disk_size_gb: NotRequired[pulumi.Input[str]]
|
|
471
|
+
disk_size_gb: NotRequired[pulumi.Input[_builtins.str]]
|
|
398
472
|
"""
|
|
399
473
|
Specifies disk size in gigabytes. Must be in increments of 2.
|
|
400
474
|
"""
|
|
401
|
-
disk_type: NotRequired[pulumi.Input[str]]
|
|
475
|
+
disk_type: NotRequired[pulumi.Input[_builtins.str]]
|
|
402
476
|
"""
|
|
403
477
|
Specifies the disk type to use to create the instance. Valid values: pd-ssd, local-ssd.
|
|
404
478
|
"""
|
|
@@ -408,15 +482,15 @@ elif False:
|
|
|
408
482
|
@pulumi.input_type
|
|
409
483
|
class ElastigroupDiskInitializeParamArgs:
|
|
410
484
|
def __init__(__self__, *,
|
|
411
|
-
source_image: pulumi.Input[str],
|
|
412
|
-
disk_size_gb: Optional[pulumi.Input[str]] = None,
|
|
413
|
-
disk_type: Optional[pulumi.Input[str]] = None):
|
|
485
|
+
source_image: pulumi.Input[_builtins.str],
|
|
486
|
+
disk_size_gb: Optional[pulumi.Input[_builtins.str]] = None,
|
|
487
|
+
disk_type: Optional[pulumi.Input[_builtins.str]] = None):
|
|
414
488
|
"""
|
|
415
|
-
:param pulumi.Input[str] source_image: A source image used to create the disk. You can provide a private (custom) image, and Compute Engine will use the corresponding image from your project.
|
|
489
|
+
:param pulumi.Input[_builtins.str] source_image: A source image used to create the disk. You can provide a private (custom) image, and Compute Engine will use the corresponding image from your project.
|
|
416
490
|
|
|
417
491
|
Usage:
|
|
418
|
-
:param pulumi.Input[str] disk_size_gb: Specifies disk size in gigabytes. Must be in increments of 2.
|
|
419
|
-
:param pulumi.Input[str] disk_type: Specifies the disk type to use to create the instance. Valid values: pd-ssd, local-ssd.
|
|
492
|
+
:param pulumi.Input[_builtins.str] disk_size_gb: Specifies disk size in gigabytes. Must be in increments of 2.
|
|
493
|
+
:param pulumi.Input[_builtins.str] disk_type: Specifies the disk type to use to create the instance. Valid values: pd-ssd, local-ssd.
|
|
420
494
|
"""
|
|
421
495
|
pulumi.set(__self__, "source_image", source_image)
|
|
422
496
|
if disk_size_gb is not None:
|
|
@@ -424,9 +498,9 @@ class ElastigroupDiskInitializeParamArgs:
|
|
|
424
498
|
if disk_type is not None:
|
|
425
499
|
pulumi.set(__self__, "disk_type", disk_type)
|
|
426
500
|
|
|
427
|
-
@property
|
|
501
|
+
@_builtins.property
|
|
428
502
|
@pulumi.getter(name="sourceImage")
|
|
429
|
-
def source_image(self) -> pulumi.Input[str]:
|
|
503
|
+
def source_image(self) -> pulumi.Input[_builtins.str]:
|
|
430
504
|
"""
|
|
431
505
|
A source image used to create the disk. You can provide a private (custom) image, and Compute Engine will use the corresponding image from your project.
|
|
432
506
|
|
|
@@ -435,43 +509,43 @@ class ElastigroupDiskInitializeParamArgs:
|
|
|
435
509
|
return pulumi.get(self, "source_image")
|
|
436
510
|
|
|
437
511
|
@source_image.setter
|
|
438
|
-
def source_image(self, value: pulumi.Input[str]):
|
|
512
|
+
def source_image(self, value: pulumi.Input[_builtins.str]):
|
|
439
513
|
pulumi.set(self, "source_image", value)
|
|
440
514
|
|
|
441
|
-
@property
|
|
515
|
+
@_builtins.property
|
|
442
516
|
@pulumi.getter(name="diskSizeGb")
|
|
443
|
-
def disk_size_gb(self) -> Optional[pulumi.Input[str]]:
|
|
517
|
+
def disk_size_gb(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
444
518
|
"""
|
|
445
519
|
Specifies disk size in gigabytes. Must be in increments of 2.
|
|
446
520
|
"""
|
|
447
521
|
return pulumi.get(self, "disk_size_gb")
|
|
448
522
|
|
|
449
523
|
@disk_size_gb.setter
|
|
450
|
-
def disk_size_gb(self, value: Optional[pulumi.Input[str]]):
|
|
524
|
+
def disk_size_gb(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
451
525
|
pulumi.set(self, "disk_size_gb", value)
|
|
452
526
|
|
|
453
|
-
@property
|
|
527
|
+
@_builtins.property
|
|
454
528
|
@pulumi.getter(name="diskType")
|
|
455
|
-
def disk_type(self) -> Optional[pulumi.Input[str]]:
|
|
529
|
+
def disk_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
456
530
|
"""
|
|
457
531
|
Specifies the disk type to use to create the instance. Valid values: pd-ssd, local-ssd.
|
|
458
532
|
"""
|
|
459
533
|
return pulumi.get(self, "disk_type")
|
|
460
534
|
|
|
461
535
|
@disk_type.setter
|
|
462
|
-
def disk_type(self, value: Optional[pulumi.Input[str]]):
|
|
536
|
+
def disk_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
463
537
|
pulumi.set(self, "disk_type", value)
|
|
464
538
|
|
|
465
539
|
|
|
466
540
|
if not MYPY:
|
|
467
541
|
class ElastigroupGpuArgsDict(TypedDict):
|
|
468
|
-
count: pulumi.Input[int]
|
|
542
|
+
count: pulumi.Input[_builtins.int]
|
|
469
543
|
"""
|
|
470
544
|
The number of GPUs. Must be 0, 2, 4, 6, 8.
|
|
471
545
|
|
|
472
546
|
Usage:
|
|
473
547
|
"""
|
|
474
|
-
type: pulumi.Input[str]
|
|
548
|
+
type: pulumi.Input[_builtins.str]
|
|
475
549
|
"""
|
|
476
550
|
The type of GPU instance. Valid values: `nvidia-tesla-v100`, `nvidia-tesla-p100`, `nvidia-tesla-k80`.
|
|
477
551
|
"""
|
|
@@ -481,20 +555,20 @@ elif False:
|
|
|
481
555
|
@pulumi.input_type
|
|
482
556
|
class ElastigroupGpuArgs:
|
|
483
557
|
def __init__(__self__, *,
|
|
484
|
-
count: pulumi.Input[int],
|
|
485
|
-
type: pulumi.Input[str]):
|
|
558
|
+
count: pulumi.Input[_builtins.int],
|
|
559
|
+
type: pulumi.Input[_builtins.str]):
|
|
486
560
|
"""
|
|
487
|
-
:param pulumi.Input[int] count: The number of GPUs. Must be 0, 2, 4, 6, 8.
|
|
561
|
+
:param pulumi.Input[_builtins.int] count: The number of GPUs. Must be 0, 2, 4, 6, 8.
|
|
488
562
|
|
|
489
563
|
Usage:
|
|
490
|
-
:param pulumi.Input[str] type: The type of GPU instance. Valid values: `nvidia-tesla-v100`, `nvidia-tesla-p100`, `nvidia-tesla-k80`.
|
|
564
|
+
:param pulumi.Input[_builtins.str] type: The type of GPU instance. Valid values: `nvidia-tesla-v100`, `nvidia-tesla-p100`, `nvidia-tesla-k80`.
|
|
491
565
|
"""
|
|
492
566
|
pulumi.set(__self__, "count", count)
|
|
493
567
|
pulumi.set(__self__, "type", type)
|
|
494
568
|
|
|
495
|
-
@property
|
|
569
|
+
@_builtins.property
|
|
496
570
|
@pulumi.getter
|
|
497
|
-
def count(self) -> pulumi.Input[int]:
|
|
571
|
+
def count(self) -> pulumi.Input[_builtins.int]:
|
|
498
572
|
"""
|
|
499
573
|
The number of GPUs. Must be 0, 2, 4, 6, 8.
|
|
500
574
|
|
|
@@ -503,72 +577,72 @@ class ElastigroupGpuArgs:
|
|
|
503
577
|
return pulumi.get(self, "count")
|
|
504
578
|
|
|
505
579
|
@count.setter
|
|
506
|
-
def count(self, value: pulumi.Input[int]):
|
|
580
|
+
def count(self, value: pulumi.Input[_builtins.int]):
|
|
507
581
|
pulumi.set(self, "count", value)
|
|
508
582
|
|
|
509
|
-
@property
|
|
583
|
+
@_builtins.property
|
|
510
584
|
@pulumi.getter
|
|
511
|
-
def type(self) -> pulumi.Input[str]:
|
|
585
|
+
def type(self) -> pulumi.Input[_builtins.str]:
|
|
512
586
|
"""
|
|
513
587
|
The type of GPU instance. Valid values: `nvidia-tesla-v100`, `nvidia-tesla-p100`, `nvidia-tesla-k80`.
|
|
514
588
|
"""
|
|
515
589
|
return pulumi.get(self, "type")
|
|
516
590
|
|
|
517
591
|
@type.setter
|
|
518
|
-
def type(self, value: pulumi.Input[str]):
|
|
592
|
+
def type(self, value: pulumi.Input[_builtins.str]):
|
|
519
593
|
pulumi.set(self, "type", value)
|
|
520
594
|
|
|
521
595
|
|
|
522
596
|
if not MYPY:
|
|
523
597
|
class ElastigroupInstanceTypesCustomArgsDict(TypedDict):
|
|
524
|
-
memory_gib: pulumi.Input[int]
|
|
598
|
+
memory_gib: pulumi.Input[_builtins.int]
|
|
525
599
|
"""
|
|
526
600
|
The memory (in GiB) in the custom instance types. GCP has a number of limitations on accepted memory values.For more information, see the GCP documentation (here.)[https://cloud.google.com/compute/docs/instances/creating-instance-with-custom-machine-type#specifications]
|
|
527
601
|
"""
|
|
528
|
-
vcpu: pulumi.Input[int]
|
|
602
|
+
vcpu: pulumi.Input[_builtins.int]
|
|
529
603
|
elif False:
|
|
530
604
|
ElastigroupInstanceTypesCustomArgsDict: TypeAlias = Mapping[str, Any]
|
|
531
605
|
|
|
532
606
|
@pulumi.input_type
|
|
533
607
|
class ElastigroupInstanceTypesCustomArgs:
|
|
534
608
|
def __init__(__self__, *,
|
|
535
|
-
memory_gib: pulumi.Input[int],
|
|
536
|
-
vcpu: pulumi.Input[int]):
|
|
609
|
+
memory_gib: pulumi.Input[_builtins.int],
|
|
610
|
+
vcpu: pulumi.Input[_builtins.int]):
|
|
537
611
|
"""
|
|
538
|
-
:param pulumi.Input[int] memory_gib: The memory (in GiB) in the custom instance types. GCP has a number of limitations on accepted memory values.For more information, see the GCP documentation (here.)[https://cloud.google.com/compute/docs/instances/creating-instance-with-custom-machine-type#specifications]
|
|
612
|
+
:param pulumi.Input[_builtins.int] memory_gib: The memory (in GiB) in the custom instance types. GCP has a number of limitations on accepted memory values.For more information, see the GCP documentation (here.)[https://cloud.google.com/compute/docs/instances/creating-instance-with-custom-machine-type#specifications]
|
|
539
613
|
"""
|
|
540
614
|
pulumi.set(__self__, "memory_gib", memory_gib)
|
|
541
615
|
pulumi.set(__self__, "vcpu", vcpu)
|
|
542
616
|
|
|
543
|
-
@property
|
|
617
|
+
@_builtins.property
|
|
544
618
|
@pulumi.getter(name="memoryGib")
|
|
545
|
-
def memory_gib(self) -> pulumi.Input[int]:
|
|
619
|
+
def memory_gib(self) -> pulumi.Input[_builtins.int]:
|
|
546
620
|
"""
|
|
547
621
|
The memory (in GiB) in the custom instance types. GCP has a number of limitations on accepted memory values.For more information, see the GCP documentation (here.)[https://cloud.google.com/compute/docs/instances/creating-instance-with-custom-machine-type#specifications]
|
|
548
622
|
"""
|
|
549
623
|
return pulumi.get(self, "memory_gib")
|
|
550
624
|
|
|
551
625
|
@memory_gib.setter
|
|
552
|
-
def memory_gib(self, value: pulumi.Input[int]):
|
|
626
|
+
def memory_gib(self, value: pulumi.Input[_builtins.int]):
|
|
553
627
|
pulumi.set(self, "memory_gib", value)
|
|
554
628
|
|
|
555
|
-
@property
|
|
629
|
+
@_builtins.property
|
|
556
630
|
@pulumi.getter
|
|
557
|
-
def vcpu(self) -> pulumi.Input[int]:
|
|
631
|
+
def vcpu(self) -> pulumi.Input[_builtins.int]:
|
|
558
632
|
return pulumi.get(self, "vcpu")
|
|
559
633
|
|
|
560
634
|
@vcpu.setter
|
|
561
|
-
def vcpu(self, value: pulumi.Input[int]):
|
|
635
|
+
def vcpu(self, value: pulumi.Input[_builtins.int]):
|
|
562
636
|
pulumi.set(self, "vcpu", value)
|
|
563
637
|
|
|
564
638
|
|
|
565
639
|
if not MYPY:
|
|
566
640
|
class ElastigroupIntegrationDockerSwarmArgsDict(TypedDict):
|
|
567
|
-
master_host: pulumi.Input[str]
|
|
641
|
+
master_host: pulumi.Input[_builtins.str]
|
|
568
642
|
"""
|
|
569
643
|
IP or FQDN of one of your swarm managers.
|
|
570
644
|
"""
|
|
571
|
-
master_port: pulumi.Input[int]
|
|
645
|
+
master_port: pulumi.Input[_builtins.int]
|
|
572
646
|
"""
|
|
573
647
|
Network port used by your swarm.
|
|
574
648
|
|
|
@@ -580,32 +654,32 @@ elif False:
|
|
|
580
654
|
@pulumi.input_type
|
|
581
655
|
class ElastigroupIntegrationDockerSwarmArgs:
|
|
582
656
|
def __init__(__self__, *,
|
|
583
|
-
master_host: pulumi.Input[str],
|
|
584
|
-
master_port: pulumi.Input[int]):
|
|
657
|
+
master_host: pulumi.Input[_builtins.str],
|
|
658
|
+
master_port: pulumi.Input[_builtins.int]):
|
|
585
659
|
"""
|
|
586
|
-
:param pulumi.Input[str] master_host: IP or FQDN of one of your swarm managers.
|
|
587
|
-
:param pulumi.Input[int] master_port: Network port used by your swarm.
|
|
660
|
+
:param pulumi.Input[_builtins.str] master_host: IP or FQDN of one of your swarm managers.
|
|
661
|
+
:param pulumi.Input[_builtins.int] master_port: Network port used by your swarm.
|
|
588
662
|
|
|
589
663
|
Usage:
|
|
590
664
|
"""
|
|
591
665
|
pulumi.set(__self__, "master_host", master_host)
|
|
592
666
|
pulumi.set(__self__, "master_port", master_port)
|
|
593
667
|
|
|
594
|
-
@property
|
|
668
|
+
@_builtins.property
|
|
595
669
|
@pulumi.getter(name="masterHost")
|
|
596
|
-
def master_host(self) -> pulumi.Input[str]:
|
|
670
|
+
def master_host(self) -> pulumi.Input[_builtins.str]:
|
|
597
671
|
"""
|
|
598
672
|
IP or FQDN of one of your swarm managers.
|
|
599
673
|
"""
|
|
600
674
|
return pulumi.get(self, "master_host")
|
|
601
675
|
|
|
602
676
|
@master_host.setter
|
|
603
|
-
def master_host(self, value: pulumi.Input[str]):
|
|
677
|
+
def master_host(self, value: pulumi.Input[_builtins.str]):
|
|
604
678
|
pulumi.set(self, "master_host", value)
|
|
605
679
|
|
|
606
|
-
@property
|
|
680
|
+
@_builtins.property
|
|
607
681
|
@pulumi.getter(name="masterPort")
|
|
608
|
-
def master_port(self) -> pulumi.Input[int]:
|
|
682
|
+
def master_port(self) -> pulumi.Input[_builtins.int]:
|
|
609
683
|
"""
|
|
610
684
|
Network port used by your swarm.
|
|
611
685
|
|
|
@@ -614,36 +688,36 @@ class ElastigroupIntegrationDockerSwarmArgs:
|
|
|
614
688
|
return pulumi.get(self, "master_port")
|
|
615
689
|
|
|
616
690
|
@master_port.setter
|
|
617
|
-
def master_port(self, value: pulumi.Input[int]):
|
|
691
|
+
def master_port(self, value: pulumi.Input[_builtins.int]):
|
|
618
692
|
pulumi.set(self, "master_port", value)
|
|
619
693
|
|
|
620
694
|
|
|
621
695
|
if not MYPY:
|
|
622
696
|
class ElastigroupIntegrationGkeArgsDict(TypedDict):
|
|
623
|
-
auto_update: NotRequired[pulumi.Input[bool]]
|
|
624
|
-
autoscale_cooldown: NotRequired[pulumi.Input[int]]
|
|
697
|
+
auto_update: NotRequired[pulumi.Input[_builtins.bool]]
|
|
698
|
+
autoscale_cooldown: NotRequired[pulumi.Input[_builtins.int]]
|
|
625
699
|
autoscale_down: NotRequired[pulumi.Input['ElastigroupIntegrationGkeAutoscaleDownArgsDict']]
|
|
626
700
|
autoscale_headroom: NotRequired[pulumi.Input['ElastigroupIntegrationGkeAutoscaleHeadroomArgsDict']]
|
|
627
|
-
autoscale_is_auto_config: NotRequired[pulumi.Input[bool]]
|
|
628
|
-
autoscale_is_enabled: NotRequired[pulumi.Input[bool]]
|
|
701
|
+
autoscale_is_auto_config: NotRequired[pulumi.Input[_builtins.bool]]
|
|
702
|
+
autoscale_is_enabled: NotRequired[pulumi.Input[_builtins.bool]]
|
|
629
703
|
autoscale_labels: NotRequired[pulumi.Input[Sequence[pulumi.Input['ElastigroupIntegrationGkeAutoscaleLabelArgsDict']]]]
|
|
630
|
-
cluster_id: NotRequired[pulumi.Input[str]]
|
|
631
|
-
location: NotRequired[pulumi.Input[str]]
|
|
704
|
+
cluster_id: NotRequired[pulumi.Input[_builtins.str]]
|
|
705
|
+
location: NotRequired[pulumi.Input[_builtins.str]]
|
|
632
706
|
elif False:
|
|
633
707
|
ElastigroupIntegrationGkeArgsDict: TypeAlias = Mapping[str, Any]
|
|
634
708
|
|
|
635
709
|
@pulumi.input_type
|
|
636
710
|
class ElastigroupIntegrationGkeArgs:
|
|
637
711
|
def __init__(__self__, *,
|
|
638
|
-
auto_update: Optional[pulumi.Input[bool]] = None,
|
|
639
|
-
autoscale_cooldown: Optional[pulumi.Input[int]] = None,
|
|
712
|
+
auto_update: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
713
|
+
autoscale_cooldown: Optional[pulumi.Input[_builtins.int]] = None,
|
|
640
714
|
autoscale_down: Optional[pulumi.Input['ElastigroupIntegrationGkeAutoscaleDownArgs']] = None,
|
|
641
715
|
autoscale_headroom: Optional[pulumi.Input['ElastigroupIntegrationGkeAutoscaleHeadroomArgs']] = None,
|
|
642
|
-
autoscale_is_auto_config: Optional[pulumi.Input[bool]] = None,
|
|
643
|
-
autoscale_is_enabled: Optional[pulumi.Input[bool]] = None,
|
|
716
|
+
autoscale_is_auto_config: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
717
|
+
autoscale_is_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
644
718
|
autoscale_labels: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupIntegrationGkeAutoscaleLabelArgs']]]] = None,
|
|
645
|
-
cluster_id: Optional[pulumi.Input[str]] = None,
|
|
646
|
-
location: Optional[pulumi.Input[str]] = None):
|
|
719
|
+
cluster_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
720
|
+
location: Optional[pulumi.Input[_builtins.str]] = None):
|
|
647
721
|
if auto_update is not None:
|
|
648
722
|
pulumi.set(__self__, "auto_update", auto_update)
|
|
649
723
|
if autoscale_cooldown is not None:
|
|
@@ -663,25 +737,25 @@ class ElastigroupIntegrationGkeArgs:
|
|
|
663
737
|
if location is not None:
|
|
664
738
|
pulumi.set(__self__, "location", location)
|
|
665
739
|
|
|
666
|
-
@property
|
|
740
|
+
@_builtins.property
|
|
667
741
|
@pulumi.getter(name="autoUpdate")
|
|
668
|
-
def auto_update(self) -> Optional[pulumi.Input[bool]]:
|
|
742
|
+
def auto_update(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
669
743
|
return pulumi.get(self, "auto_update")
|
|
670
744
|
|
|
671
745
|
@auto_update.setter
|
|
672
|
-
def auto_update(self, value: Optional[pulumi.Input[bool]]):
|
|
746
|
+
def auto_update(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
673
747
|
pulumi.set(self, "auto_update", value)
|
|
674
748
|
|
|
675
|
-
@property
|
|
749
|
+
@_builtins.property
|
|
676
750
|
@pulumi.getter(name="autoscaleCooldown")
|
|
677
|
-
def autoscale_cooldown(self) -> Optional[pulumi.Input[int]]:
|
|
751
|
+
def autoscale_cooldown(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
678
752
|
return pulumi.get(self, "autoscale_cooldown")
|
|
679
753
|
|
|
680
754
|
@autoscale_cooldown.setter
|
|
681
|
-
def autoscale_cooldown(self, value: Optional[pulumi.Input[int]]):
|
|
755
|
+
def autoscale_cooldown(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
682
756
|
pulumi.set(self, "autoscale_cooldown", value)
|
|
683
757
|
|
|
684
|
-
@property
|
|
758
|
+
@_builtins.property
|
|
685
759
|
@pulumi.getter(name="autoscaleDown")
|
|
686
760
|
def autoscale_down(self) -> Optional[pulumi.Input['ElastigroupIntegrationGkeAutoscaleDownArgs']]:
|
|
687
761
|
return pulumi.get(self, "autoscale_down")
|
|
@@ -690,7 +764,7 @@ class ElastigroupIntegrationGkeArgs:
|
|
|
690
764
|
def autoscale_down(self, value: Optional[pulumi.Input['ElastigroupIntegrationGkeAutoscaleDownArgs']]):
|
|
691
765
|
pulumi.set(self, "autoscale_down", value)
|
|
692
766
|
|
|
693
|
-
@property
|
|
767
|
+
@_builtins.property
|
|
694
768
|
@pulumi.getter(name="autoscaleHeadroom")
|
|
695
769
|
def autoscale_headroom(self) -> Optional[pulumi.Input['ElastigroupIntegrationGkeAutoscaleHeadroomArgs']]:
|
|
696
770
|
return pulumi.get(self, "autoscale_headroom")
|
|
@@ -699,25 +773,25 @@ class ElastigroupIntegrationGkeArgs:
|
|
|
699
773
|
def autoscale_headroom(self, value: Optional[pulumi.Input['ElastigroupIntegrationGkeAutoscaleHeadroomArgs']]):
|
|
700
774
|
pulumi.set(self, "autoscale_headroom", value)
|
|
701
775
|
|
|
702
|
-
@property
|
|
776
|
+
@_builtins.property
|
|
703
777
|
@pulumi.getter(name="autoscaleIsAutoConfig")
|
|
704
|
-
def autoscale_is_auto_config(self) -> Optional[pulumi.Input[bool]]:
|
|
778
|
+
def autoscale_is_auto_config(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
705
779
|
return pulumi.get(self, "autoscale_is_auto_config")
|
|
706
780
|
|
|
707
781
|
@autoscale_is_auto_config.setter
|
|
708
|
-
def autoscale_is_auto_config(self, value: Optional[pulumi.Input[bool]]):
|
|
782
|
+
def autoscale_is_auto_config(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
709
783
|
pulumi.set(self, "autoscale_is_auto_config", value)
|
|
710
784
|
|
|
711
|
-
@property
|
|
785
|
+
@_builtins.property
|
|
712
786
|
@pulumi.getter(name="autoscaleIsEnabled")
|
|
713
|
-
def autoscale_is_enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
787
|
+
def autoscale_is_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
714
788
|
return pulumi.get(self, "autoscale_is_enabled")
|
|
715
789
|
|
|
716
790
|
@autoscale_is_enabled.setter
|
|
717
|
-
def autoscale_is_enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
791
|
+
def autoscale_is_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
718
792
|
pulumi.set(self, "autoscale_is_enabled", value)
|
|
719
793
|
|
|
720
|
-
@property
|
|
794
|
+
@_builtins.property
|
|
721
795
|
@pulumi.getter(name="autoscaleLabels")
|
|
722
796
|
def autoscale_labels(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupIntegrationGkeAutoscaleLabelArgs']]]]:
|
|
723
797
|
return pulumi.get(self, "autoscale_labels")
|
|
@@ -726,28 +800,28 @@ class ElastigroupIntegrationGkeArgs:
|
|
|
726
800
|
def autoscale_labels(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupIntegrationGkeAutoscaleLabelArgs']]]]):
|
|
727
801
|
pulumi.set(self, "autoscale_labels", value)
|
|
728
802
|
|
|
729
|
-
@property
|
|
803
|
+
@_builtins.property
|
|
730
804
|
@pulumi.getter(name="clusterId")
|
|
731
|
-
def cluster_id(self) -> Optional[pulumi.Input[str]]:
|
|
805
|
+
def cluster_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
732
806
|
return pulumi.get(self, "cluster_id")
|
|
733
807
|
|
|
734
808
|
@cluster_id.setter
|
|
735
|
-
def cluster_id(self, value: Optional[pulumi.Input[str]]):
|
|
809
|
+
def cluster_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
736
810
|
pulumi.set(self, "cluster_id", value)
|
|
737
811
|
|
|
738
|
-
@property
|
|
812
|
+
@_builtins.property
|
|
739
813
|
@pulumi.getter
|
|
740
|
-
def location(self) -> Optional[pulumi.Input[str]]:
|
|
814
|
+
def location(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
741
815
|
return pulumi.get(self, "location")
|
|
742
816
|
|
|
743
817
|
@location.setter
|
|
744
|
-
def location(self, value: Optional[pulumi.Input[str]]):
|
|
818
|
+
def location(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
745
819
|
pulumi.set(self, "location", value)
|
|
746
820
|
|
|
747
821
|
|
|
748
822
|
if not MYPY:
|
|
749
823
|
class ElastigroupIntegrationGkeAutoscaleDownArgsDict(TypedDict):
|
|
750
|
-
evaluation_periods: NotRequired[pulumi.Input[int]]
|
|
824
|
+
evaluation_periods: NotRequired[pulumi.Input[_builtins.int]]
|
|
751
825
|
"""
|
|
752
826
|
Number of consecutive periods in which the threshold must be met in order to trigger a scaling action.
|
|
753
827
|
"""
|
|
@@ -757,40 +831,40 @@ elif False:
|
|
|
757
831
|
@pulumi.input_type
|
|
758
832
|
class ElastigroupIntegrationGkeAutoscaleDownArgs:
|
|
759
833
|
def __init__(__self__, *,
|
|
760
|
-
evaluation_periods: Optional[pulumi.Input[int]] = None):
|
|
834
|
+
evaluation_periods: Optional[pulumi.Input[_builtins.int]] = None):
|
|
761
835
|
"""
|
|
762
|
-
:param pulumi.Input[int] evaluation_periods: Number of consecutive periods in which the threshold must be met in order to trigger a scaling action.
|
|
836
|
+
:param pulumi.Input[_builtins.int] evaluation_periods: Number of consecutive periods in which the threshold must be met in order to trigger a scaling action.
|
|
763
837
|
"""
|
|
764
838
|
if evaluation_periods is not None:
|
|
765
839
|
pulumi.set(__self__, "evaluation_periods", evaluation_periods)
|
|
766
840
|
|
|
767
|
-
@property
|
|
841
|
+
@_builtins.property
|
|
768
842
|
@pulumi.getter(name="evaluationPeriods")
|
|
769
|
-
def evaluation_periods(self) -> Optional[pulumi.Input[int]]:
|
|
843
|
+
def evaluation_periods(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
770
844
|
"""
|
|
771
845
|
Number of consecutive periods in which the threshold must be met in order to trigger a scaling action.
|
|
772
846
|
"""
|
|
773
847
|
return pulumi.get(self, "evaluation_periods")
|
|
774
848
|
|
|
775
849
|
@evaluation_periods.setter
|
|
776
|
-
def evaluation_periods(self, value: Optional[pulumi.Input[int]]):
|
|
850
|
+
def evaluation_periods(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
777
851
|
pulumi.set(self, "evaluation_periods", value)
|
|
778
852
|
|
|
779
853
|
|
|
780
854
|
if not MYPY:
|
|
781
855
|
class ElastigroupIntegrationGkeAutoscaleHeadroomArgsDict(TypedDict):
|
|
782
|
-
cpu_per_unit: NotRequired[pulumi.Input[int]]
|
|
783
|
-
memory_per_unit: NotRequired[pulumi.Input[int]]
|
|
784
|
-
num_of_units: NotRequired[pulumi.Input[int]]
|
|
856
|
+
cpu_per_unit: NotRequired[pulumi.Input[_builtins.int]]
|
|
857
|
+
memory_per_unit: NotRequired[pulumi.Input[_builtins.int]]
|
|
858
|
+
num_of_units: NotRequired[pulumi.Input[_builtins.int]]
|
|
785
859
|
elif False:
|
|
786
860
|
ElastigroupIntegrationGkeAutoscaleHeadroomArgsDict: TypeAlias = Mapping[str, Any]
|
|
787
861
|
|
|
788
862
|
@pulumi.input_type
|
|
789
863
|
class ElastigroupIntegrationGkeAutoscaleHeadroomArgs:
|
|
790
864
|
def __init__(__self__, *,
|
|
791
|
-
cpu_per_unit: Optional[pulumi.Input[int]] = None,
|
|
792
|
-
memory_per_unit: Optional[pulumi.Input[int]] = None,
|
|
793
|
-
num_of_units: Optional[pulumi.Input[int]] = None):
|
|
865
|
+
cpu_per_unit: Optional[pulumi.Input[_builtins.int]] = None,
|
|
866
|
+
memory_per_unit: Optional[pulumi.Input[_builtins.int]] = None,
|
|
867
|
+
num_of_units: Optional[pulumi.Input[_builtins.int]] = None):
|
|
794
868
|
if cpu_per_unit is not None:
|
|
795
869
|
pulumi.set(__self__, "cpu_per_unit", cpu_per_unit)
|
|
796
870
|
if memory_per_unit is not None:
|
|
@@ -798,75 +872,75 @@ class ElastigroupIntegrationGkeAutoscaleHeadroomArgs:
|
|
|
798
872
|
if num_of_units is not None:
|
|
799
873
|
pulumi.set(__self__, "num_of_units", num_of_units)
|
|
800
874
|
|
|
801
|
-
@property
|
|
875
|
+
@_builtins.property
|
|
802
876
|
@pulumi.getter(name="cpuPerUnit")
|
|
803
|
-
def cpu_per_unit(self) -> Optional[pulumi.Input[int]]:
|
|
877
|
+
def cpu_per_unit(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
804
878
|
return pulumi.get(self, "cpu_per_unit")
|
|
805
879
|
|
|
806
880
|
@cpu_per_unit.setter
|
|
807
|
-
def cpu_per_unit(self, value: Optional[pulumi.Input[int]]):
|
|
881
|
+
def cpu_per_unit(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
808
882
|
pulumi.set(self, "cpu_per_unit", value)
|
|
809
883
|
|
|
810
|
-
@property
|
|
884
|
+
@_builtins.property
|
|
811
885
|
@pulumi.getter(name="memoryPerUnit")
|
|
812
|
-
def memory_per_unit(self) -> Optional[pulumi.Input[int]]:
|
|
886
|
+
def memory_per_unit(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
813
887
|
return pulumi.get(self, "memory_per_unit")
|
|
814
888
|
|
|
815
889
|
@memory_per_unit.setter
|
|
816
|
-
def memory_per_unit(self, value: Optional[pulumi.Input[int]]):
|
|
890
|
+
def memory_per_unit(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
817
891
|
pulumi.set(self, "memory_per_unit", value)
|
|
818
892
|
|
|
819
|
-
@property
|
|
893
|
+
@_builtins.property
|
|
820
894
|
@pulumi.getter(name="numOfUnits")
|
|
821
|
-
def num_of_units(self) -> Optional[pulumi.Input[int]]:
|
|
895
|
+
def num_of_units(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
822
896
|
return pulumi.get(self, "num_of_units")
|
|
823
897
|
|
|
824
898
|
@num_of_units.setter
|
|
825
|
-
def num_of_units(self, value: Optional[pulumi.Input[int]]):
|
|
899
|
+
def num_of_units(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
826
900
|
pulumi.set(self, "num_of_units", value)
|
|
827
901
|
|
|
828
902
|
|
|
829
903
|
if not MYPY:
|
|
830
904
|
class ElastigroupIntegrationGkeAutoscaleLabelArgsDict(TypedDict):
|
|
831
|
-
key: pulumi.Input[str]
|
|
832
|
-
value: pulumi.Input[str]
|
|
905
|
+
key: pulumi.Input[_builtins.str]
|
|
906
|
+
value: pulumi.Input[_builtins.str]
|
|
833
907
|
elif False:
|
|
834
908
|
ElastigroupIntegrationGkeAutoscaleLabelArgsDict: TypeAlias = Mapping[str, Any]
|
|
835
909
|
|
|
836
910
|
@pulumi.input_type
|
|
837
911
|
class ElastigroupIntegrationGkeAutoscaleLabelArgs:
|
|
838
912
|
def __init__(__self__, *,
|
|
839
|
-
key: pulumi.Input[str],
|
|
840
|
-
value: pulumi.Input[str]):
|
|
913
|
+
key: pulumi.Input[_builtins.str],
|
|
914
|
+
value: pulumi.Input[_builtins.str]):
|
|
841
915
|
pulumi.set(__self__, "key", key)
|
|
842
916
|
pulumi.set(__self__, "value", value)
|
|
843
917
|
|
|
844
|
-
@property
|
|
918
|
+
@_builtins.property
|
|
845
919
|
@pulumi.getter
|
|
846
|
-
def key(self) -> pulumi.Input[str]:
|
|
920
|
+
def key(self) -> pulumi.Input[_builtins.str]:
|
|
847
921
|
return pulumi.get(self, "key")
|
|
848
922
|
|
|
849
923
|
@key.setter
|
|
850
|
-
def key(self, value: pulumi.Input[str]):
|
|
924
|
+
def key(self, value: pulumi.Input[_builtins.str]):
|
|
851
925
|
pulumi.set(self, "key", value)
|
|
852
926
|
|
|
853
|
-
@property
|
|
927
|
+
@_builtins.property
|
|
854
928
|
@pulumi.getter
|
|
855
|
-
def value(self) -> pulumi.Input[str]:
|
|
929
|
+
def value(self) -> pulumi.Input[_builtins.str]:
|
|
856
930
|
return pulumi.get(self, "value")
|
|
857
931
|
|
|
858
932
|
@value.setter
|
|
859
|
-
def value(self, value: pulumi.Input[str]):
|
|
933
|
+
def value(self, value: pulumi.Input[_builtins.str]):
|
|
860
934
|
pulumi.set(self, "value", value)
|
|
861
935
|
|
|
862
936
|
|
|
863
937
|
if not MYPY:
|
|
864
938
|
class ElastigroupLabelArgsDict(TypedDict):
|
|
865
|
-
key: pulumi.Input[str]
|
|
939
|
+
key: pulumi.Input[_builtins.str]
|
|
866
940
|
"""
|
|
867
941
|
Labels key.
|
|
868
942
|
"""
|
|
869
|
-
value: pulumi.Input[str]
|
|
943
|
+
value: pulumi.Input[_builtins.str]
|
|
870
944
|
"""
|
|
871
945
|
Labels value.
|
|
872
946
|
"""
|
|
@@ -876,47 +950,47 @@ elif False:
|
|
|
876
950
|
@pulumi.input_type
|
|
877
951
|
class ElastigroupLabelArgs:
|
|
878
952
|
def __init__(__self__, *,
|
|
879
|
-
key: pulumi.Input[str],
|
|
880
|
-
value: pulumi.Input[str]):
|
|
953
|
+
key: pulumi.Input[_builtins.str],
|
|
954
|
+
value: pulumi.Input[_builtins.str]):
|
|
881
955
|
"""
|
|
882
|
-
:param pulumi.Input[str] key: Labels key.
|
|
883
|
-
:param pulumi.Input[str] value: Labels value.
|
|
956
|
+
:param pulumi.Input[_builtins.str] key: Labels key.
|
|
957
|
+
:param pulumi.Input[_builtins.str] value: Labels value.
|
|
884
958
|
"""
|
|
885
959
|
pulumi.set(__self__, "key", key)
|
|
886
960
|
pulumi.set(__self__, "value", value)
|
|
887
961
|
|
|
888
|
-
@property
|
|
962
|
+
@_builtins.property
|
|
889
963
|
@pulumi.getter
|
|
890
|
-
def key(self) -> pulumi.Input[str]:
|
|
964
|
+
def key(self) -> pulumi.Input[_builtins.str]:
|
|
891
965
|
"""
|
|
892
966
|
Labels key.
|
|
893
967
|
"""
|
|
894
968
|
return pulumi.get(self, "key")
|
|
895
969
|
|
|
896
970
|
@key.setter
|
|
897
|
-
def key(self, value: pulumi.Input[str]):
|
|
971
|
+
def key(self, value: pulumi.Input[_builtins.str]):
|
|
898
972
|
pulumi.set(self, "key", value)
|
|
899
973
|
|
|
900
|
-
@property
|
|
974
|
+
@_builtins.property
|
|
901
975
|
@pulumi.getter
|
|
902
|
-
def value(self) -> pulumi.Input[str]:
|
|
976
|
+
def value(self) -> pulumi.Input[_builtins.str]:
|
|
903
977
|
"""
|
|
904
978
|
Labels value.
|
|
905
979
|
"""
|
|
906
980
|
return pulumi.get(self, "value")
|
|
907
981
|
|
|
908
982
|
@value.setter
|
|
909
|
-
def value(self, value: pulumi.Input[str]):
|
|
983
|
+
def value(self, value: pulumi.Input[_builtins.str]):
|
|
910
984
|
pulumi.set(self, "value", value)
|
|
911
985
|
|
|
912
986
|
|
|
913
987
|
if not MYPY:
|
|
914
988
|
class ElastigroupMetadataArgsDict(TypedDict):
|
|
915
|
-
key: pulumi.Input[str]
|
|
989
|
+
key: pulumi.Input[_builtins.str]
|
|
916
990
|
"""
|
|
917
991
|
Metadata key.
|
|
918
992
|
"""
|
|
919
|
-
value: pulumi.Input[str]
|
|
993
|
+
value: pulumi.Input[_builtins.str]
|
|
920
994
|
"""
|
|
921
995
|
Metadata value.
|
|
922
996
|
"""
|
|
@@ -926,43 +1000,43 @@ elif False:
|
|
|
926
1000
|
@pulumi.input_type
|
|
927
1001
|
class ElastigroupMetadataArgs:
|
|
928
1002
|
def __init__(__self__, *,
|
|
929
|
-
key: pulumi.Input[str],
|
|
930
|
-
value: pulumi.Input[str]):
|
|
1003
|
+
key: pulumi.Input[_builtins.str],
|
|
1004
|
+
value: pulumi.Input[_builtins.str]):
|
|
931
1005
|
"""
|
|
932
|
-
:param pulumi.Input[str] key: Metadata key.
|
|
933
|
-
:param pulumi.Input[str] value: Metadata value.
|
|
1006
|
+
:param pulumi.Input[_builtins.str] key: Metadata key.
|
|
1007
|
+
:param pulumi.Input[_builtins.str] value: Metadata value.
|
|
934
1008
|
"""
|
|
935
1009
|
pulumi.set(__self__, "key", key)
|
|
936
1010
|
pulumi.set(__self__, "value", value)
|
|
937
1011
|
|
|
938
|
-
@property
|
|
1012
|
+
@_builtins.property
|
|
939
1013
|
@pulumi.getter
|
|
940
|
-
def key(self) -> pulumi.Input[str]:
|
|
1014
|
+
def key(self) -> pulumi.Input[_builtins.str]:
|
|
941
1015
|
"""
|
|
942
1016
|
Metadata key.
|
|
943
1017
|
"""
|
|
944
1018
|
return pulumi.get(self, "key")
|
|
945
1019
|
|
|
946
1020
|
@key.setter
|
|
947
|
-
def key(self, value: pulumi.Input[str]):
|
|
1021
|
+
def key(self, value: pulumi.Input[_builtins.str]):
|
|
948
1022
|
pulumi.set(self, "key", value)
|
|
949
1023
|
|
|
950
|
-
@property
|
|
1024
|
+
@_builtins.property
|
|
951
1025
|
@pulumi.getter
|
|
952
|
-
def value(self) -> pulumi.Input[str]:
|
|
1026
|
+
def value(self) -> pulumi.Input[_builtins.str]:
|
|
953
1027
|
"""
|
|
954
1028
|
Metadata value.
|
|
955
1029
|
"""
|
|
956
1030
|
return pulumi.get(self, "value")
|
|
957
1031
|
|
|
958
1032
|
@value.setter
|
|
959
|
-
def value(self, value: pulumi.Input[str]):
|
|
1033
|
+
def value(self, value: pulumi.Input[_builtins.str]):
|
|
960
1034
|
pulumi.set(self, "value", value)
|
|
961
1035
|
|
|
962
1036
|
|
|
963
1037
|
if not MYPY:
|
|
964
1038
|
class ElastigroupNetworkInterfaceArgsDict(TypedDict):
|
|
965
|
-
network: pulumi.Input[str]
|
|
1039
|
+
network: pulumi.Input[_builtins.str]
|
|
966
1040
|
"""
|
|
967
1041
|
Network resource for this group.
|
|
968
1042
|
"""
|
|
@@ -977,11 +1051,11 @@ elif False:
|
|
|
977
1051
|
@pulumi.input_type
|
|
978
1052
|
class ElastigroupNetworkInterfaceArgs:
|
|
979
1053
|
def __init__(__self__, *,
|
|
980
|
-
network: pulumi.Input[str],
|
|
1054
|
+
network: pulumi.Input[_builtins.str],
|
|
981
1055
|
access_configs: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupNetworkInterfaceAccessConfigArgs']]]] = None,
|
|
982
1056
|
alias_ip_ranges: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupNetworkInterfaceAliasIpRangeArgs']]]] = None):
|
|
983
1057
|
"""
|
|
984
|
-
:param pulumi.Input[str] network: Network resource for this group.
|
|
1058
|
+
:param pulumi.Input[_builtins.str] network: Network resource for this group.
|
|
985
1059
|
:param pulumi.Input[Sequence[pulumi.Input['ElastigroupNetworkInterfaceAccessConfigArgs']]] access_configs: Array of configurations.
|
|
986
1060
|
"""
|
|
987
1061
|
pulumi.set(__self__, "network", network)
|
|
@@ -990,19 +1064,19 @@ class ElastigroupNetworkInterfaceArgs:
|
|
|
990
1064
|
if alias_ip_ranges is not None:
|
|
991
1065
|
pulumi.set(__self__, "alias_ip_ranges", alias_ip_ranges)
|
|
992
1066
|
|
|
993
|
-
@property
|
|
1067
|
+
@_builtins.property
|
|
994
1068
|
@pulumi.getter
|
|
995
|
-
def network(self) -> pulumi.Input[str]:
|
|
1069
|
+
def network(self) -> pulumi.Input[_builtins.str]:
|
|
996
1070
|
"""
|
|
997
1071
|
Network resource for this group.
|
|
998
1072
|
"""
|
|
999
1073
|
return pulumi.get(self, "network")
|
|
1000
1074
|
|
|
1001
1075
|
@network.setter
|
|
1002
|
-
def network(self, value: pulumi.Input[str]):
|
|
1076
|
+
def network(self, value: pulumi.Input[_builtins.str]):
|
|
1003
1077
|
pulumi.set(self, "network", value)
|
|
1004
1078
|
|
|
1005
|
-
@property
|
|
1079
|
+
@_builtins.property
|
|
1006
1080
|
@pulumi.getter(name="accessConfigs")
|
|
1007
1081
|
def access_configs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupNetworkInterfaceAccessConfigArgs']]]]:
|
|
1008
1082
|
"""
|
|
@@ -1014,7 +1088,7 @@ class ElastigroupNetworkInterfaceArgs:
|
|
|
1014
1088
|
def access_configs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupNetworkInterfaceAccessConfigArgs']]]]):
|
|
1015
1089
|
pulumi.set(self, "access_configs", value)
|
|
1016
1090
|
|
|
1017
|
-
@property
|
|
1091
|
+
@_builtins.property
|
|
1018
1092
|
@pulumi.getter(name="aliasIpRanges")
|
|
1019
1093
|
def alias_ip_ranges(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupNetworkInterfaceAliasIpRangeArgs']]]]:
|
|
1020
1094
|
return pulumi.get(self, "alias_ip_ranges")
|
|
@@ -1026,86 +1100,86 @@ class ElastigroupNetworkInterfaceArgs:
|
|
|
1026
1100
|
|
|
1027
1101
|
if not MYPY:
|
|
1028
1102
|
class ElastigroupNetworkInterfaceAccessConfigArgsDict(TypedDict):
|
|
1029
|
-
name: NotRequired[pulumi.Input[str]]
|
|
1103
|
+
name: NotRequired[pulumi.Input[_builtins.str]]
|
|
1030
1104
|
"""
|
|
1031
1105
|
The group name.
|
|
1032
1106
|
"""
|
|
1033
|
-
type: NotRequired[pulumi.Input[str]]
|
|
1107
|
+
type: NotRequired[pulumi.Input[_builtins.str]]
|
|
1034
1108
|
elif False:
|
|
1035
1109
|
ElastigroupNetworkInterfaceAccessConfigArgsDict: TypeAlias = Mapping[str, Any]
|
|
1036
1110
|
|
|
1037
1111
|
@pulumi.input_type
|
|
1038
1112
|
class ElastigroupNetworkInterfaceAccessConfigArgs:
|
|
1039
1113
|
def __init__(__self__, *,
|
|
1040
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
1041
|
-
type: Optional[pulumi.Input[str]] = None):
|
|
1114
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1115
|
+
type: Optional[pulumi.Input[_builtins.str]] = None):
|
|
1042
1116
|
"""
|
|
1043
|
-
:param pulumi.Input[str] name: The group name.
|
|
1117
|
+
:param pulumi.Input[_builtins.str] name: The group name.
|
|
1044
1118
|
"""
|
|
1045
1119
|
if name is not None:
|
|
1046
1120
|
pulumi.set(__self__, "name", name)
|
|
1047
1121
|
if type is not None:
|
|
1048
1122
|
pulumi.set(__self__, "type", type)
|
|
1049
1123
|
|
|
1050
|
-
@property
|
|
1124
|
+
@_builtins.property
|
|
1051
1125
|
@pulumi.getter
|
|
1052
|
-
def name(self) -> Optional[pulumi.Input[str]]:
|
|
1126
|
+
def name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1053
1127
|
"""
|
|
1054
1128
|
The group name.
|
|
1055
1129
|
"""
|
|
1056
1130
|
return pulumi.get(self, "name")
|
|
1057
1131
|
|
|
1058
1132
|
@name.setter
|
|
1059
|
-
def name(self, value: Optional[pulumi.Input[str]]):
|
|
1133
|
+
def name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1060
1134
|
pulumi.set(self, "name", value)
|
|
1061
1135
|
|
|
1062
|
-
@property
|
|
1136
|
+
@_builtins.property
|
|
1063
1137
|
@pulumi.getter
|
|
1064
|
-
def type(self) -> Optional[pulumi.Input[str]]:
|
|
1138
|
+
def type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1065
1139
|
return pulumi.get(self, "type")
|
|
1066
1140
|
|
|
1067
1141
|
@type.setter
|
|
1068
|
-
def type(self, value: Optional[pulumi.Input[str]]):
|
|
1142
|
+
def type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1069
1143
|
pulumi.set(self, "type", value)
|
|
1070
1144
|
|
|
1071
1145
|
|
|
1072
1146
|
if not MYPY:
|
|
1073
1147
|
class ElastigroupNetworkInterfaceAliasIpRangeArgsDict(TypedDict):
|
|
1074
|
-
ip_cidr_range: pulumi.Input[str]
|
|
1075
|
-
subnetwork_range_name: pulumi.Input[str]
|
|
1148
|
+
ip_cidr_range: pulumi.Input[_builtins.str]
|
|
1149
|
+
subnetwork_range_name: pulumi.Input[_builtins.str]
|
|
1076
1150
|
elif False:
|
|
1077
1151
|
ElastigroupNetworkInterfaceAliasIpRangeArgsDict: TypeAlias = Mapping[str, Any]
|
|
1078
1152
|
|
|
1079
1153
|
@pulumi.input_type
|
|
1080
1154
|
class ElastigroupNetworkInterfaceAliasIpRangeArgs:
|
|
1081
1155
|
def __init__(__self__, *,
|
|
1082
|
-
ip_cidr_range: pulumi.Input[str],
|
|
1083
|
-
subnetwork_range_name: pulumi.Input[str]):
|
|
1156
|
+
ip_cidr_range: pulumi.Input[_builtins.str],
|
|
1157
|
+
subnetwork_range_name: pulumi.Input[_builtins.str]):
|
|
1084
1158
|
pulumi.set(__self__, "ip_cidr_range", ip_cidr_range)
|
|
1085
1159
|
pulumi.set(__self__, "subnetwork_range_name", subnetwork_range_name)
|
|
1086
1160
|
|
|
1087
|
-
@property
|
|
1161
|
+
@_builtins.property
|
|
1088
1162
|
@pulumi.getter(name="ipCidrRange")
|
|
1089
|
-
def ip_cidr_range(self) -> pulumi.Input[str]:
|
|
1163
|
+
def ip_cidr_range(self) -> pulumi.Input[_builtins.str]:
|
|
1090
1164
|
return pulumi.get(self, "ip_cidr_range")
|
|
1091
1165
|
|
|
1092
1166
|
@ip_cidr_range.setter
|
|
1093
|
-
def ip_cidr_range(self, value: pulumi.Input[str]):
|
|
1167
|
+
def ip_cidr_range(self, value: pulumi.Input[_builtins.str]):
|
|
1094
1168
|
pulumi.set(self, "ip_cidr_range", value)
|
|
1095
1169
|
|
|
1096
|
-
@property
|
|
1170
|
+
@_builtins.property
|
|
1097
1171
|
@pulumi.getter(name="subnetworkRangeName")
|
|
1098
|
-
def subnetwork_range_name(self) -> pulumi.Input[str]:
|
|
1172
|
+
def subnetwork_range_name(self) -> pulumi.Input[_builtins.str]:
|
|
1099
1173
|
return pulumi.get(self, "subnetwork_range_name")
|
|
1100
1174
|
|
|
1101
1175
|
@subnetwork_range_name.setter
|
|
1102
|
-
def subnetwork_range_name(self, value: pulumi.Input[str]):
|
|
1176
|
+
def subnetwork_range_name(self, value: pulumi.Input[_builtins.str]):
|
|
1103
1177
|
pulumi.set(self, "subnetwork_range_name", value)
|
|
1104
1178
|
|
|
1105
1179
|
|
|
1106
1180
|
if not MYPY:
|
|
1107
1181
|
class ElastigroupRevertToPreemptibleArgsDict(TypedDict):
|
|
1108
|
-
perform_at: pulumi.Input[str]
|
|
1182
|
+
perform_at: pulumi.Input[_builtins.str]
|
|
1109
1183
|
"""
|
|
1110
1184
|
Valid values: "always", "never", "timeWindow". Required on strategy.revertToPreemptible object.
|
|
1111
1185
|
"""
|
|
@@ -1115,50 +1189,50 @@ elif False:
|
|
|
1115
1189
|
@pulumi.input_type
|
|
1116
1190
|
class ElastigroupRevertToPreemptibleArgs:
|
|
1117
1191
|
def __init__(__self__, *,
|
|
1118
|
-
perform_at: pulumi.Input[str]):
|
|
1192
|
+
perform_at: pulumi.Input[_builtins.str]):
|
|
1119
1193
|
"""
|
|
1120
|
-
:param pulumi.Input[str] perform_at: Valid values: "always", "never", "timeWindow". Required on strategy.revertToPreemptible object.
|
|
1194
|
+
:param pulumi.Input[_builtins.str] perform_at: Valid values: "always", "never", "timeWindow". Required on strategy.revertToPreemptible object.
|
|
1121
1195
|
"""
|
|
1122
1196
|
pulumi.set(__self__, "perform_at", perform_at)
|
|
1123
1197
|
|
|
1124
|
-
@property
|
|
1198
|
+
@_builtins.property
|
|
1125
1199
|
@pulumi.getter(name="performAt")
|
|
1126
|
-
def perform_at(self) -> pulumi.Input[str]:
|
|
1200
|
+
def perform_at(self) -> pulumi.Input[_builtins.str]:
|
|
1127
1201
|
"""
|
|
1128
1202
|
Valid values: "always", "never", "timeWindow". Required on strategy.revertToPreemptible object.
|
|
1129
1203
|
"""
|
|
1130
1204
|
return pulumi.get(self, "perform_at")
|
|
1131
1205
|
|
|
1132
1206
|
@perform_at.setter
|
|
1133
|
-
def perform_at(self, value: pulumi.Input[str]):
|
|
1207
|
+
def perform_at(self, value: pulumi.Input[_builtins.str]):
|
|
1134
1208
|
pulumi.set(self, "perform_at", value)
|
|
1135
1209
|
|
|
1136
1210
|
|
|
1137
1211
|
if not MYPY:
|
|
1138
1212
|
class ElastigroupScalingDownPolicyArgsDict(TypedDict):
|
|
1139
|
-
metric_name: pulumi.Input[str]
|
|
1213
|
+
metric_name: pulumi.Input[_builtins.str]
|
|
1140
1214
|
"""
|
|
1141
1215
|
Metric to monitor. Valid values: "Percentage CPU", "Network In", "Network Out", "Disk Read Bytes", "Disk Write Bytes", "Disk Write Operations/Sec", "Disk Read Operations/Sec".
|
|
1142
1216
|
"""
|
|
1143
|
-
namespace: pulumi.Input[str]
|
|
1144
|
-
policy_name: pulumi.Input[str]
|
|
1217
|
+
namespace: pulumi.Input[_builtins.str]
|
|
1218
|
+
policy_name: pulumi.Input[_builtins.str]
|
|
1145
1219
|
"""
|
|
1146
1220
|
Name of scaling policy.
|
|
1147
1221
|
"""
|
|
1148
|
-
threshold: pulumi.Input[float]
|
|
1222
|
+
threshold: pulumi.Input[_builtins.float]
|
|
1149
1223
|
"""
|
|
1150
1224
|
The value at which the scaling action is triggered.
|
|
1151
1225
|
"""
|
|
1152
|
-
unit: pulumi.Input[str]
|
|
1153
|
-
action_type: NotRequired[pulumi.Input[str]]
|
|
1226
|
+
unit: pulumi.Input[_builtins.str]
|
|
1227
|
+
action_type: NotRequired[pulumi.Input[_builtins.str]]
|
|
1154
1228
|
"""
|
|
1155
1229
|
Type of scaling action to take when the scaling policy is triggered. Valid values: "adjustment", "setMinTarget", "updateCapacity", "percentageAdjustment"
|
|
1156
1230
|
"""
|
|
1157
|
-
adjustment: NotRequired[pulumi.Input[int]]
|
|
1231
|
+
adjustment: NotRequired[pulumi.Input[_builtins.int]]
|
|
1158
1232
|
"""
|
|
1159
1233
|
Value to which the action type will be adjusted. Required if using "numeric" or "percentageAdjustment" action types.
|
|
1160
1234
|
"""
|
|
1161
|
-
cooldown: NotRequired[pulumi.Input[int]]
|
|
1235
|
+
cooldown: NotRequired[pulumi.Input[_builtins.int]]
|
|
1162
1236
|
"""
|
|
1163
1237
|
Time (seconds) to wait after a scaling action before resuming monitoring.
|
|
1164
1238
|
"""
|
|
@@ -1166,23 +1240,23 @@ if not MYPY:
|
|
|
1166
1240
|
"""
|
|
1167
1241
|
A list of dimensions describing qualities of the metric.
|
|
1168
1242
|
"""
|
|
1169
|
-
evaluation_periods: NotRequired[pulumi.Input[int]]
|
|
1243
|
+
evaluation_periods: NotRequired[pulumi.Input[_builtins.int]]
|
|
1170
1244
|
"""
|
|
1171
1245
|
Number of consecutive periods in which the threshold must be met in order to trigger a scaling action.
|
|
1172
1246
|
"""
|
|
1173
|
-
operator: NotRequired[pulumi.Input[str]]
|
|
1247
|
+
operator: NotRequired[pulumi.Input[_builtins.str]]
|
|
1174
1248
|
"""
|
|
1175
1249
|
The operator used to evaluate the threshold against the current metric value. Valid values: "gt" (greater than), "get" (greater-than or equal), "lt" (less than), "lte" (less than or equal).
|
|
1176
1250
|
"""
|
|
1177
|
-
period: NotRequired[pulumi.Input[int]]
|
|
1251
|
+
period: NotRequired[pulumi.Input[_builtins.int]]
|
|
1178
1252
|
"""
|
|
1179
1253
|
Amount of time (seconds) for which the threshold must be met in order to trigger the scaling action.
|
|
1180
1254
|
"""
|
|
1181
|
-
source: NotRequired[pulumi.Input[str]]
|
|
1255
|
+
source: NotRequired[pulumi.Input[_builtins.str]]
|
|
1182
1256
|
"""
|
|
1183
1257
|
Specifies a valid partial or full URL to an existing Persistent Disk resource. This field is only applicable for persistent disks.
|
|
1184
1258
|
"""
|
|
1185
|
-
statistic: NotRequired[pulumi.Input[str]]
|
|
1259
|
+
statistic: NotRequired[pulumi.Input[_builtins.str]]
|
|
1186
1260
|
"""
|
|
1187
1261
|
Statistic by which to evaluate the selected metric. Valid values: "AVERAGE", "SAMPLE_COUNT", "SUM", "MINIMUM", "MAXIMUM", "PERCENTILE", "COUNT".
|
|
1188
1262
|
"""
|
|
@@ -1192,33 +1266,33 @@ elif False:
|
|
|
1192
1266
|
@pulumi.input_type
|
|
1193
1267
|
class ElastigroupScalingDownPolicyArgs:
|
|
1194
1268
|
def __init__(__self__, *,
|
|
1195
|
-
metric_name: pulumi.Input[str],
|
|
1196
|
-
namespace: pulumi.Input[str],
|
|
1197
|
-
policy_name: pulumi.Input[str],
|
|
1198
|
-
threshold: pulumi.Input[float],
|
|
1199
|
-
unit: pulumi.Input[str],
|
|
1200
|
-
action_type: Optional[pulumi.Input[str]] = None,
|
|
1201
|
-
adjustment: Optional[pulumi.Input[int]] = None,
|
|
1202
|
-
cooldown: Optional[pulumi.Input[int]] = None,
|
|
1269
|
+
metric_name: pulumi.Input[_builtins.str],
|
|
1270
|
+
namespace: pulumi.Input[_builtins.str],
|
|
1271
|
+
policy_name: pulumi.Input[_builtins.str],
|
|
1272
|
+
threshold: pulumi.Input[_builtins.float],
|
|
1273
|
+
unit: pulumi.Input[_builtins.str],
|
|
1274
|
+
action_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1275
|
+
adjustment: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1276
|
+
cooldown: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1203
1277
|
dimensions: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingDownPolicyDimensionArgs']]]] = None,
|
|
1204
|
-
evaluation_periods: Optional[pulumi.Input[int]] = None,
|
|
1205
|
-
operator: Optional[pulumi.Input[str]] = None,
|
|
1206
|
-
period: Optional[pulumi.Input[int]] = None,
|
|
1207
|
-
source: Optional[pulumi.Input[str]] = None,
|
|
1208
|
-
statistic: Optional[pulumi.Input[str]] = None):
|
|
1209
|
-
"""
|
|
1210
|
-
:param pulumi.Input[str] metric_name: Metric to monitor. Valid values: "Percentage CPU", "Network In", "Network Out", "Disk Read Bytes", "Disk Write Bytes", "Disk Write Operations/Sec", "Disk Read Operations/Sec".
|
|
1211
|
-
:param pulumi.Input[str] policy_name: Name of scaling policy.
|
|
1212
|
-
:param pulumi.Input[float] threshold: The value at which the scaling action is triggered.
|
|
1213
|
-
:param pulumi.Input[str] action_type: Type of scaling action to take when the scaling policy is triggered. Valid values: "adjustment", "setMinTarget", "updateCapacity", "percentageAdjustment"
|
|
1214
|
-
:param pulumi.Input[int] adjustment: Value to which the action type will be adjusted. Required if using "numeric" or "percentageAdjustment" action types.
|
|
1215
|
-
:param pulumi.Input[int] cooldown: Time (seconds) to wait after a scaling action before resuming monitoring.
|
|
1278
|
+
evaluation_periods: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1279
|
+
operator: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1280
|
+
period: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1281
|
+
source: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1282
|
+
statistic: Optional[pulumi.Input[_builtins.str]] = None):
|
|
1283
|
+
"""
|
|
1284
|
+
:param pulumi.Input[_builtins.str] metric_name: Metric to monitor. Valid values: "Percentage CPU", "Network In", "Network Out", "Disk Read Bytes", "Disk Write Bytes", "Disk Write Operations/Sec", "Disk Read Operations/Sec".
|
|
1285
|
+
:param pulumi.Input[_builtins.str] policy_name: Name of scaling policy.
|
|
1286
|
+
:param pulumi.Input[_builtins.float] threshold: The value at which the scaling action is triggered.
|
|
1287
|
+
:param pulumi.Input[_builtins.str] action_type: Type of scaling action to take when the scaling policy is triggered. Valid values: "adjustment", "setMinTarget", "updateCapacity", "percentageAdjustment"
|
|
1288
|
+
:param pulumi.Input[_builtins.int] adjustment: Value to which the action type will be adjusted. Required if using "numeric" or "percentageAdjustment" action types.
|
|
1289
|
+
:param pulumi.Input[_builtins.int] cooldown: Time (seconds) to wait after a scaling action before resuming monitoring.
|
|
1216
1290
|
:param pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingDownPolicyDimensionArgs']]] dimensions: A list of dimensions describing qualities of the metric.
|
|
1217
|
-
:param pulumi.Input[int] evaluation_periods: Number of consecutive periods in which the threshold must be met in order to trigger a scaling action.
|
|
1218
|
-
:param pulumi.Input[str] operator: The operator used to evaluate the threshold against the current metric value. Valid values: "gt" (greater than), "get" (greater-than or equal), "lt" (less than), "lte" (less than or equal).
|
|
1219
|
-
:param pulumi.Input[int] period: Amount of time (seconds) for which the threshold must be met in order to trigger the scaling action.
|
|
1220
|
-
:param pulumi.Input[str] source: Specifies a valid partial or full URL to an existing Persistent Disk resource. This field is only applicable for persistent disks.
|
|
1221
|
-
:param pulumi.Input[str] statistic: Statistic by which to evaluate the selected metric. Valid values: "AVERAGE", "SAMPLE_COUNT", "SUM", "MINIMUM", "MAXIMUM", "PERCENTILE", "COUNT".
|
|
1291
|
+
:param pulumi.Input[_builtins.int] evaluation_periods: Number of consecutive periods in which the threshold must be met in order to trigger a scaling action.
|
|
1292
|
+
:param pulumi.Input[_builtins.str] operator: The operator used to evaluate the threshold against the current metric value. Valid values: "gt" (greater than), "get" (greater-than or equal), "lt" (less than), "lte" (less than or equal).
|
|
1293
|
+
:param pulumi.Input[_builtins.int] period: Amount of time (seconds) for which the threshold must be met in order to trigger the scaling action.
|
|
1294
|
+
:param pulumi.Input[_builtins.str] source: Specifies a valid partial or full URL to an existing Persistent Disk resource. This field is only applicable for persistent disks.
|
|
1295
|
+
:param pulumi.Input[_builtins.str] statistic: Statistic by which to evaluate the selected metric. Valid values: "AVERAGE", "SAMPLE_COUNT", "SUM", "MINIMUM", "MAXIMUM", "PERCENTILE", "COUNT".
|
|
1222
1296
|
"""
|
|
1223
1297
|
pulumi.set(__self__, "metric_name", metric_name)
|
|
1224
1298
|
pulumi.set(__self__, "namespace", namespace)
|
|
@@ -1244,97 +1318,97 @@ class ElastigroupScalingDownPolicyArgs:
|
|
|
1244
1318
|
if statistic is not None:
|
|
1245
1319
|
pulumi.set(__self__, "statistic", statistic)
|
|
1246
1320
|
|
|
1247
|
-
@property
|
|
1321
|
+
@_builtins.property
|
|
1248
1322
|
@pulumi.getter(name="metricName")
|
|
1249
|
-
def metric_name(self) -> pulumi.Input[str]:
|
|
1323
|
+
def metric_name(self) -> pulumi.Input[_builtins.str]:
|
|
1250
1324
|
"""
|
|
1251
1325
|
Metric to monitor. Valid values: "Percentage CPU", "Network In", "Network Out", "Disk Read Bytes", "Disk Write Bytes", "Disk Write Operations/Sec", "Disk Read Operations/Sec".
|
|
1252
1326
|
"""
|
|
1253
1327
|
return pulumi.get(self, "metric_name")
|
|
1254
1328
|
|
|
1255
1329
|
@metric_name.setter
|
|
1256
|
-
def metric_name(self, value: pulumi.Input[str]):
|
|
1330
|
+
def metric_name(self, value: pulumi.Input[_builtins.str]):
|
|
1257
1331
|
pulumi.set(self, "metric_name", value)
|
|
1258
1332
|
|
|
1259
|
-
@property
|
|
1333
|
+
@_builtins.property
|
|
1260
1334
|
@pulumi.getter
|
|
1261
|
-
def namespace(self) -> pulumi.Input[str]:
|
|
1335
|
+
def namespace(self) -> pulumi.Input[_builtins.str]:
|
|
1262
1336
|
return pulumi.get(self, "namespace")
|
|
1263
1337
|
|
|
1264
1338
|
@namespace.setter
|
|
1265
|
-
def namespace(self, value: pulumi.Input[str]):
|
|
1339
|
+
def namespace(self, value: pulumi.Input[_builtins.str]):
|
|
1266
1340
|
pulumi.set(self, "namespace", value)
|
|
1267
1341
|
|
|
1268
|
-
@property
|
|
1342
|
+
@_builtins.property
|
|
1269
1343
|
@pulumi.getter(name="policyName")
|
|
1270
|
-
def policy_name(self) -> pulumi.Input[str]:
|
|
1344
|
+
def policy_name(self) -> pulumi.Input[_builtins.str]:
|
|
1271
1345
|
"""
|
|
1272
1346
|
Name of scaling policy.
|
|
1273
1347
|
"""
|
|
1274
1348
|
return pulumi.get(self, "policy_name")
|
|
1275
1349
|
|
|
1276
1350
|
@policy_name.setter
|
|
1277
|
-
def policy_name(self, value: pulumi.Input[str]):
|
|
1351
|
+
def policy_name(self, value: pulumi.Input[_builtins.str]):
|
|
1278
1352
|
pulumi.set(self, "policy_name", value)
|
|
1279
1353
|
|
|
1280
|
-
@property
|
|
1354
|
+
@_builtins.property
|
|
1281
1355
|
@pulumi.getter
|
|
1282
|
-
def threshold(self) -> pulumi.Input[float]:
|
|
1356
|
+
def threshold(self) -> pulumi.Input[_builtins.float]:
|
|
1283
1357
|
"""
|
|
1284
1358
|
The value at which the scaling action is triggered.
|
|
1285
1359
|
"""
|
|
1286
1360
|
return pulumi.get(self, "threshold")
|
|
1287
1361
|
|
|
1288
1362
|
@threshold.setter
|
|
1289
|
-
def threshold(self, value: pulumi.Input[float]):
|
|
1363
|
+
def threshold(self, value: pulumi.Input[_builtins.float]):
|
|
1290
1364
|
pulumi.set(self, "threshold", value)
|
|
1291
1365
|
|
|
1292
|
-
@property
|
|
1366
|
+
@_builtins.property
|
|
1293
1367
|
@pulumi.getter
|
|
1294
|
-
def unit(self) -> pulumi.Input[str]:
|
|
1368
|
+
def unit(self) -> pulumi.Input[_builtins.str]:
|
|
1295
1369
|
return pulumi.get(self, "unit")
|
|
1296
1370
|
|
|
1297
1371
|
@unit.setter
|
|
1298
|
-
def unit(self, value: pulumi.Input[str]):
|
|
1372
|
+
def unit(self, value: pulumi.Input[_builtins.str]):
|
|
1299
1373
|
pulumi.set(self, "unit", value)
|
|
1300
1374
|
|
|
1301
|
-
@property
|
|
1375
|
+
@_builtins.property
|
|
1302
1376
|
@pulumi.getter(name="actionType")
|
|
1303
|
-
def action_type(self) -> Optional[pulumi.Input[str]]:
|
|
1377
|
+
def action_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1304
1378
|
"""
|
|
1305
1379
|
Type of scaling action to take when the scaling policy is triggered. Valid values: "adjustment", "setMinTarget", "updateCapacity", "percentageAdjustment"
|
|
1306
1380
|
"""
|
|
1307
1381
|
return pulumi.get(self, "action_type")
|
|
1308
1382
|
|
|
1309
1383
|
@action_type.setter
|
|
1310
|
-
def action_type(self, value: Optional[pulumi.Input[str]]):
|
|
1384
|
+
def action_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1311
1385
|
pulumi.set(self, "action_type", value)
|
|
1312
1386
|
|
|
1313
|
-
@property
|
|
1387
|
+
@_builtins.property
|
|
1314
1388
|
@pulumi.getter
|
|
1315
|
-
def adjustment(self) -> Optional[pulumi.Input[int]]:
|
|
1389
|
+
def adjustment(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1316
1390
|
"""
|
|
1317
1391
|
Value to which the action type will be adjusted. Required if using "numeric" or "percentageAdjustment" action types.
|
|
1318
1392
|
"""
|
|
1319
1393
|
return pulumi.get(self, "adjustment")
|
|
1320
1394
|
|
|
1321
1395
|
@adjustment.setter
|
|
1322
|
-
def adjustment(self, value: Optional[pulumi.Input[int]]):
|
|
1396
|
+
def adjustment(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1323
1397
|
pulumi.set(self, "adjustment", value)
|
|
1324
1398
|
|
|
1325
|
-
@property
|
|
1399
|
+
@_builtins.property
|
|
1326
1400
|
@pulumi.getter
|
|
1327
|
-
def cooldown(self) -> Optional[pulumi.Input[int]]:
|
|
1401
|
+
def cooldown(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1328
1402
|
"""
|
|
1329
1403
|
Time (seconds) to wait after a scaling action before resuming monitoring.
|
|
1330
1404
|
"""
|
|
1331
1405
|
return pulumi.get(self, "cooldown")
|
|
1332
1406
|
|
|
1333
1407
|
@cooldown.setter
|
|
1334
|
-
def cooldown(self, value: Optional[pulumi.Input[int]]):
|
|
1408
|
+
def cooldown(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1335
1409
|
pulumi.set(self, "cooldown", value)
|
|
1336
1410
|
|
|
1337
|
-
@property
|
|
1411
|
+
@_builtins.property
|
|
1338
1412
|
@pulumi.getter
|
|
1339
1413
|
def dimensions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingDownPolicyDimensionArgs']]]]:
|
|
1340
1414
|
"""
|
|
@@ -1346,136 +1420,136 @@ class ElastigroupScalingDownPolicyArgs:
|
|
|
1346
1420
|
def dimensions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingDownPolicyDimensionArgs']]]]):
|
|
1347
1421
|
pulumi.set(self, "dimensions", value)
|
|
1348
1422
|
|
|
1349
|
-
@property
|
|
1423
|
+
@_builtins.property
|
|
1350
1424
|
@pulumi.getter(name="evaluationPeriods")
|
|
1351
|
-
def evaluation_periods(self) -> Optional[pulumi.Input[int]]:
|
|
1425
|
+
def evaluation_periods(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1352
1426
|
"""
|
|
1353
1427
|
Number of consecutive periods in which the threshold must be met in order to trigger a scaling action.
|
|
1354
1428
|
"""
|
|
1355
1429
|
return pulumi.get(self, "evaluation_periods")
|
|
1356
1430
|
|
|
1357
1431
|
@evaluation_periods.setter
|
|
1358
|
-
def evaluation_periods(self, value: Optional[pulumi.Input[int]]):
|
|
1432
|
+
def evaluation_periods(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1359
1433
|
pulumi.set(self, "evaluation_periods", value)
|
|
1360
1434
|
|
|
1361
|
-
@property
|
|
1435
|
+
@_builtins.property
|
|
1362
1436
|
@pulumi.getter
|
|
1363
|
-
def operator(self) -> Optional[pulumi.Input[str]]:
|
|
1437
|
+
def operator(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1364
1438
|
"""
|
|
1365
1439
|
The operator used to evaluate the threshold against the current metric value. Valid values: "gt" (greater than), "get" (greater-than or equal), "lt" (less than), "lte" (less than or equal).
|
|
1366
1440
|
"""
|
|
1367
1441
|
return pulumi.get(self, "operator")
|
|
1368
1442
|
|
|
1369
1443
|
@operator.setter
|
|
1370
|
-
def operator(self, value: Optional[pulumi.Input[str]]):
|
|
1444
|
+
def operator(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1371
1445
|
pulumi.set(self, "operator", value)
|
|
1372
1446
|
|
|
1373
|
-
@property
|
|
1447
|
+
@_builtins.property
|
|
1374
1448
|
@pulumi.getter
|
|
1375
|
-
def period(self) -> Optional[pulumi.Input[int]]:
|
|
1449
|
+
def period(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1376
1450
|
"""
|
|
1377
1451
|
Amount of time (seconds) for which the threshold must be met in order to trigger the scaling action.
|
|
1378
1452
|
"""
|
|
1379
1453
|
return pulumi.get(self, "period")
|
|
1380
1454
|
|
|
1381
1455
|
@period.setter
|
|
1382
|
-
def period(self, value: Optional[pulumi.Input[int]]):
|
|
1456
|
+
def period(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1383
1457
|
pulumi.set(self, "period", value)
|
|
1384
1458
|
|
|
1385
|
-
@property
|
|
1459
|
+
@_builtins.property
|
|
1386
1460
|
@pulumi.getter
|
|
1387
|
-
def source(self) -> Optional[pulumi.Input[str]]:
|
|
1461
|
+
def source(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1388
1462
|
"""
|
|
1389
1463
|
Specifies a valid partial or full URL to an existing Persistent Disk resource. This field is only applicable for persistent disks.
|
|
1390
1464
|
"""
|
|
1391
1465
|
return pulumi.get(self, "source")
|
|
1392
1466
|
|
|
1393
1467
|
@source.setter
|
|
1394
|
-
def source(self, value: Optional[pulumi.Input[str]]):
|
|
1468
|
+
def source(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1395
1469
|
pulumi.set(self, "source", value)
|
|
1396
1470
|
|
|
1397
|
-
@property
|
|
1471
|
+
@_builtins.property
|
|
1398
1472
|
@pulumi.getter
|
|
1399
|
-
def statistic(self) -> Optional[pulumi.Input[str]]:
|
|
1473
|
+
def statistic(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1400
1474
|
"""
|
|
1401
1475
|
Statistic by which to evaluate the selected metric. Valid values: "AVERAGE", "SAMPLE_COUNT", "SUM", "MINIMUM", "MAXIMUM", "PERCENTILE", "COUNT".
|
|
1402
1476
|
"""
|
|
1403
1477
|
return pulumi.get(self, "statistic")
|
|
1404
1478
|
|
|
1405
1479
|
@statistic.setter
|
|
1406
|
-
def statistic(self, value: Optional[pulumi.Input[str]]):
|
|
1480
|
+
def statistic(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1407
1481
|
pulumi.set(self, "statistic", value)
|
|
1408
1482
|
|
|
1409
1483
|
|
|
1410
1484
|
if not MYPY:
|
|
1411
1485
|
class ElastigroupScalingDownPolicyDimensionArgsDict(TypedDict):
|
|
1412
|
-
name: pulumi.Input[str]
|
|
1486
|
+
name: pulumi.Input[_builtins.str]
|
|
1413
1487
|
"""
|
|
1414
1488
|
The group name.
|
|
1415
1489
|
"""
|
|
1416
|
-
value: NotRequired[pulumi.Input[str]]
|
|
1490
|
+
value: NotRequired[pulumi.Input[_builtins.str]]
|
|
1417
1491
|
elif False:
|
|
1418
1492
|
ElastigroupScalingDownPolicyDimensionArgsDict: TypeAlias = Mapping[str, Any]
|
|
1419
1493
|
|
|
1420
1494
|
@pulumi.input_type
|
|
1421
1495
|
class ElastigroupScalingDownPolicyDimensionArgs:
|
|
1422
1496
|
def __init__(__self__, *,
|
|
1423
|
-
name: pulumi.Input[str],
|
|
1424
|
-
value: Optional[pulumi.Input[str]] = None):
|
|
1497
|
+
name: pulumi.Input[_builtins.str],
|
|
1498
|
+
value: Optional[pulumi.Input[_builtins.str]] = None):
|
|
1425
1499
|
"""
|
|
1426
|
-
:param pulumi.Input[str] name: The group name.
|
|
1500
|
+
:param pulumi.Input[_builtins.str] name: The group name.
|
|
1427
1501
|
"""
|
|
1428
1502
|
pulumi.set(__self__, "name", name)
|
|
1429
1503
|
if value is not None:
|
|
1430
1504
|
pulumi.set(__self__, "value", value)
|
|
1431
1505
|
|
|
1432
|
-
@property
|
|
1506
|
+
@_builtins.property
|
|
1433
1507
|
@pulumi.getter
|
|
1434
|
-
def name(self) -> pulumi.Input[str]:
|
|
1508
|
+
def name(self) -> pulumi.Input[_builtins.str]:
|
|
1435
1509
|
"""
|
|
1436
1510
|
The group name.
|
|
1437
1511
|
"""
|
|
1438
1512
|
return pulumi.get(self, "name")
|
|
1439
1513
|
|
|
1440
1514
|
@name.setter
|
|
1441
|
-
def name(self, value: pulumi.Input[str]):
|
|
1515
|
+
def name(self, value: pulumi.Input[_builtins.str]):
|
|
1442
1516
|
pulumi.set(self, "name", value)
|
|
1443
1517
|
|
|
1444
|
-
@property
|
|
1518
|
+
@_builtins.property
|
|
1445
1519
|
@pulumi.getter
|
|
1446
|
-
def value(self) -> Optional[pulumi.Input[str]]:
|
|
1520
|
+
def value(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1447
1521
|
return pulumi.get(self, "value")
|
|
1448
1522
|
|
|
1449
1523
|
@value.setter
|
|
1450
|
-
def value(self, value: Optional[pulumi.Input[str]]):
|
|
1524
|
+
def value(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1451
1525
|
pulumi.set(self, "value", value)
|
|
1452
1526
|
|
|
1453
1527
|
|
|
1454
1528
|
if not MYPY:
|
|
1455
1529
|
class ElastigroupScalingUpPolicyArgsDict(TypedDict):
|
|
1456
|
-
metric_name: pulumi.Input[str]
|
|
1530
|
+
metric_name: pulumi.Input[_builtins.str]
|
|
1457
1531
|
"""
|
|
1458
1532
|
Metric to monitor. Valid values: "Percentage CPU", "Network In", "Network Out", "Disk Read Bytes", "Disk Write Bytes", "Disk Write Operations/Sec", "Disk Read Operations/Sec".
|
|
1459
1533
|
"""
|
|
1460
|
-
namespace: pulumi.Input[str]
|
|
1461
|
-
policy_name: pulumi.Input[str]
|
|
1534
|
+
namespace: pulumi.Input[_builtins.str]
|
|
1535
|
+
policy_name: pulumi.Input[_builtins.str]
|
|
1462
1536
|
"""
|
|
1463
1537
|
Name of scaling policy.
|
|
1464
1538
|
"""
|
|
1465
|
-
threshold: pulumi.Input[float]
|
|
1539
|
+
threshold: pulumi.Input[_builtins.float]
|
|
1466
1540
|
"""
|
|
1467
1541
|
The value at which the scaling action is triggered.
|
|
1468
1542
|
"""
|
|
1469
|
-
unit: pulumi.Input[str]
|
|
1470
|
-
action_type: NotRequired[pulumi.Input[str]]
|
|
1543
|
+
unit: pulumi.Input[_builtins.str]
|
|
1544
|
+
action_type: NotRequired[pulumi.Input[_builtins.str]]
|
|
1471
1545
|
"""
|
|
1472
1546
|
Type of scaling action to take when the scaling policy is triggered. Valid values: "adjustment", "setMinTarget", "updateCapacity", "percentageAdjustment"
|
|
1473
1547
|
"""
|
|
1474
|
-
adjustment: NotRequired[pulumi.Input[int]]
|
|
1548
|
+
adjustment: NotRequired[pulumi.Input[_builtins.int]]
|
|
1475
1549
|
"""
|
|
1476
1550
|
Value to which the action type will be adjusted. Required if using "numeric" or "percentageAdjustment" action types.
|
|
1477
1551
|
"""
|
|
1478
|
-
cooldown: NotRequired[pulumi.Input[int]]
|
|
1552
|
+
cooldown: NotRequired[pulumi.Input[_builtins.int]]
|
|
1479
1553
|
"""
|
|
1480
1554
|
Time (seconds) to wait after a scaling action before resuming monitoring.
|
|
1481
1555
|
"""
|
|
@@ -1483,23 +1557,23 @@ if not MYPY:
|
|
|
1483
1557
|
"""
|
|
1484
1558
|
A list of dimensions describing qualities of the metric.
|
|
1485
1559
|
"""
|
|
1486
|
-
evaluation_periods: NotRequired[pulumi.Input[int]]
|
|
1560
|
+
evaluation_periods: NotRequired[pulumi.Input[_builtins.int]]
|
|
1487
1561
|
"""
|
|
1488
1562
|
Number of consecutive periods in which the threshold must be met in order to trigger a scaling action.
|
|
1489
1563
|
"""
|
|
1490
|
-
operator: NotRequired[pulumi.Input[str]]
|
|
1564
|
+
operator: NotRequired[pulumi.Input[_builtins.str]]
|
|
1491
1565
|
"""
|
|
1492
1566
|
The operator used to evaluate the threshold against the current metric value. Valid values: "gt" (greater than), "get" (greater-than or equal), "lt" (less than), "lte" (less than or equal).
|
|
1493
1567
|
"""
|
|
1494
|
-
period: NotRequired[pulumi.Input[int]]
|
|
1568
|
+
period: NotRequired[pulumi.Input[_builtins.int]]
|
|
1495
1569
|
"""
|
|
1496
1570
|
Amount of time (seconds) for which the threshold must be met in order to trigger the scaling action.
|
|
1497
1571
|
"""
|
|
1498
|
-
source: NotRequired[pulumi.Input[str]]
|
|
1572
|
+
source: NotRequired[pulumi.Input[_builtins.str]]
|
|
1499
1573
|
"""
|
|
1500
1574
|
Specifies a valid partial or full URL to an existing Persistent Disk resource. This field is only applicable for persistent disks.
|
|
1501
1575
|
"""
|
|
1502
|
-
statistic: NotRequired[pulumi.Input[str]]
|
|
1576
|
+
statistic: NotRequired[pulumi.Input[_builtins.str]]
|
|
1503
1577
|
"""
|
|
1504
1578
|
Statistic by which to evaluate the selected metric. Valid values: "AVERAGE", "SAMPLE_COUNT", "SUM", "MINIMUM", "MAXIMUM", "PERCENTILE", "COUNT".
|
|
1505
1579
|
"""
|
|
@@ -1509,33 +1583,33 @@ elif False:
|
|
|
1509
1583
|
@pulumi.input_type
|
|
1510
1584
|
class ElastigroupScalingUpPolicyArgs:
|
|
1511
1585
|
def __init__(__self__, *,
|
|
1512
|
-
metric_name: pulumi.Input[str],
|
|
1513
|
-
namespace: pulumi.Input[str],
|
|
1514
|
-
policy_name: pulumi.Input[str],
|
|
1515
|
-
threshold: pulumi.Input[float],
|
|
1516
|
-
unit: pulumi.Input[str],
|
|
1517
|
-
action_type: Optional[pulumi.Input[str]] = None,
|
|
1518
|
-
adjustment: Optional[pulumi.Input[int]] = None,
|
|
1519
|
-
cooldown: Optional[pulumi.Input[int]] = None,
|
|
1586
|
+
metric_name: pulumi.Input[_builtins.str],
|
|
1587
|
+
namespace: pulumi.Input[_builtins.str],
|
|
1588
|
+
policy_name: pulumi.Input[_builtins.str],
|
|
1589
|
+
threshold: pulumi.Input[_builtins.float],
|
|
1590
|
+
unit: pulumi.Input[_builtins.str],
|
|
1591
|
+
action_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1592
|
+
adjustment: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1593
|
+
cooldown: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1520
1594
|
dimensions: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingUpPolicyDimensionArgs']]]] = None,
|
|
1521
|
-
evaluation_periods: Optional[pulumi.Input[int]] = None,
|
|
1522
|
-
operator: Optional[pulumi.Input[str]] = None,
|
|
1523
|
-
period: Optional[pulumi.Input[int]] = None,
|
|
1524
|
-
source: Optional[pulumi.Input[str]] = None,
|
|
1525
|
-
statistic: Optional[pulumi.Input[str]] = None):
|
|
1526
|
-
"""
|
|
1527
|
-
:param pulumi.Input[str] metric_name: Metric to monitor. Valid values: "Percentage CPU", "Network In", "Network Out", "Disk Read Bytes", "Disk Write Bytes", "Disk Write Operations/Sec", "Disk Read Operations/Sec".
|
|
1528
|
-
:param pulumi.Input[str] policy_name: Name of scaling policy.
|
|
1529
|
-
:param pulumi.Input[float] threshold: The value at which the scaling action is triggered.
|
|
1530
|
-
:param pulumi.Input[str] action_type: Type of scaling action to take when the scaling policy is triggered. Valid values: "adjustment", "setMinTarget", "updateCapacity", "percentageAdjustment"
|
|
1531
|
-
:param pulumi.Input[int] adjustment: Value to which the action type will be adjusted. Required if using "numeric" or "percentageAdjustment" action types.
|
|
1532
|
-
:param pulumi.Input[int] cooldown: Time (seconds) to wait after a scaling action before resuming monitoring.
|
|
1595
|
+
evaluation_periods: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1596
|
+
operator: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1597
|
+
period: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1598
|
+
source: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1599
|
+
statistic: Optional[pulumi.Input[_builtins.str]] = None):
|
|
1600
|
+
"""
|
|
1601
|
+
:param pulumi.Input[_builtins.str] metric_name: Metric to monitor. Valid values: "Percentage CPU", "Network In", "Network Out", "Disk Read Bytes", "Disk Write Bytes", "Disk Write Operations/Sec", "Disk Read Operations/Sec".
|
|
1602
|
+
:param pulumi.Input[_builtins.str] policy_name: Name of scaling policy.
|
|
1603
|
+
:param pulumi.Input[_builtins.float] threshold: The value at which the scaling action is triggered.
|
|
1604
|
+
:param pulumi.Input[_builtins.str] action_type: Type of scaling action to take when the scaling policy is triggered. Valid values: "adjustment", "setMinTarget", "updateCapacity", "percentageAdjustment"
|
|
1605
|
+
:param pulumi.Input[_builtins.int] adjustment: Value to which the action type will be adjusted. Required if using "numeric" or "percentageAdjustment" action types.
|
|
1606
|
+
:param pulumi.Input[_builtins.int] cooldown: Time (seconds) to wait after a scaling action before resuming monitoring.
|
|
1533
1607
|
:param pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingUpPolicyDimensionArgs']]] dimensions: A list of dimensions describing qualities of the metric.
|
|
1534
|
-
:param pulumi.Input[int] evaluation_periods: Number of consecutive periods in which the threshold must be met in order to trigger a scaling action.
|
|
1535
|
-
:param pulumi.Input[str] operator: The operator used to evaluate the threshold against the current metric value. Valid values: "gt" (greater than), "get" (greater-than or equal), "lt" (less than), "lte" (less than or equal).
|
|
1536
|
-
:param pulumi.Input[int] period: Amount of time (seconds) for which the threshold must be met in order to trigger the scaling action.
|
|
1537
|
-
:param pulumi.Input[str] source: Specifies a valid partial or full URL to an existing Persistent Disk resource. This field is only applicable for persistent disks.
|
|
1538
|
-
:param pulumi.Input[str] statistic: Statistic by which to evaluate the selected metric. Valid values: "AVERAGE", "SAMPLE_COUNT", "SUM", "MINIMUM", "MAXIMUM", "PERCENTILE", "COUNT".
|
|
1608
|
+
:param pulumi.Input[_builtins.int] evaluation_periods: Number of consecutive periods in which the threshold must be met in order to trigger a scaling action.
|
|
1609
|
+
:param pulumi.Input[_builtins.str] operator: The operator used to evaluate the threshold against the current metric value. Valid values: "gt" (greater than), "get" (greater-than or equal), "lt" (less than), "lte" (less than or equal).
|
|
1610
|
+
:param pulumi.Input[_builtins.int] period: Amount of time (seconds) for which the threshold must be met in order to trigger the scaling action.
|
|
1611
|
+
:param pulumi.Input[_builtins.str] source: Specifies a valid partial or full URL to an existing Persistent Disk resource. This field is only applicable for persistent disks.
|
|
1612
|
+
:param pulumi.Input[_builtins.str] statistic: Statistic by which to evaluate the selected metric. Valid values: "AVERAGE", "SAMPLE_COUNT", "SUM", "MINIMUM", "MAXIMUM", "PERCENTILE", "COUNT".
|
|
1539
1613
|
"""
|
|
1540
1614
|
pulumi.set(__self__, "metric_name", metric_name)
|
|
1541
1615
|
pulumi.set(__self__, "namespace", namespace)
|
|
@@ -1561,97 +1635,97 @@ class ElastigroupScalingUpPolicyArgs:
|
|
|
1561
1635
|
if statistic is not None:
|
|
1562
1636
|
pulumi.set(__self__, "statistic", statistic)
|
|
1563
1637
|
|
|
1564
|
-
@property
|
|
1638
|
+
@_builtins.property
|
|
1565
1639
|
@pulumi.getter(name="metricName")
|
|
1566
|
-
def metric_name(self) -> pulumi.Input[str]:
|
|
1640
|
+
def metric_name(self) -> pulumi.Input[_builtins.str]:
|
|
1567
1641
|
"""
|
|
1568
1642
|
Metric to monitor. Valid values: "Percentage CPU", "Network In", "Network Out", "Disk Read Bytes", "Disk Write Bytes", "Disk Write Operations/Sec", "Disk Read Operations/Sec".
|
|
1569
1643
|
"""
|
|
1570
1644
|
return pulumi.get(self, "metric_name")
|
|
1571
1645
|
|
|
1572
1646
|
@metric_name.setter
|
|
1573
|
-
def metric_name(self, value: pulumi.Input[str]):
|
|
1647
|
+
def metric_name(self, value: pulumi.Input[_builtins.str]):
|
|
1574
1648
|
pulumi.set(self, "metric_name", value)
|
|
1575
1649
|
|
|
1576
|
-
@property
|
|
1650
|
+
@_builtins.property
|
|
1577
1651
|
@pulumi.getter
|
|
1578
|
-
def namespace(self) -> pulumi.Input[str]:
|
|
1652
|
+
def namespace(self) -> pulumi.Input[_builtins.str]:
|
|
1579
1653
|
return pulumi.get(self, "namespace")
|
|
1580
1654
|
|
|
1581
1655
|
@namespace.setter
|
|
1582
|
-
def namespace(self, value: pulumi.Input[str]):
|
|
1656
|
+
def namespace(self, value: pulumi.Input[_builtins.str]):
|
|
1583
1657
|
pulumi.set(self, "namespace", value)
|
|
1584
1658
|
|
|
1585
|
-
@property
|
|
1659
|
+
@_builtins.property
|
|
1586
1660
|
@pulumi.getter(name="policyName")
|
|
1587
|
-
def policy_name(self) -> pulumi.Input[str]:
|
|
1661
|
+
def policy_name(self) -> pulumi.Input[_builtins.str]:
|
|
1588
1662
|
"""
|
|
1589
1663
|
Name of scaling policy.
|
|
1590
1664
|
"""
|
|
1591
1665
|
return pulumi.get(self, "policy_name")
|
|
1592
1666
|
|
|
1593
1667
|
@policy_name.setter
|
|
1594
|
-
def policy_name(self, value: pulumi.Input[str]):
|
|
1668
|
+
def policy_name(self, value: pulumi.Input[_builtins.str]):
|
|
1595
1669
|
pulumi.set(self, "policy_name", value)
|
|
1596
1670
|
|
|
1597
|
-
@property
|
|
1671
|
+
@_builtins.property
|
|
1598
1672
|
@pulumi.getter
|
|
1599
|
-
def threshold(self) -> pulumi.Input[float]:
|
|
1673
|
+
def threshold(self) -> pulumi.Input[_builtins.float]:
|
|
1600
1674
|
"""
|
|
1601
1675
|
The value at which the scaling action is triggered.
|
|
1602
1676
|
"""
|
|
1603
1677
|
return pulumi.get(self, "threshold")
|
|
1604
1678
|
|
|
1605
1679
|
@threshold.setter
|
|
1606
|
-
def threshold(self, value: pulumi.Input[float]):
|
|
1680
|
+
def threshold(self, value: pulumi.Input[_builtins.float]):
|
|
1607
1681
|
pulumi.set(self, "threshold", value)
|
|
1608
1682
|
|
|
1609
|
-
@property
|
|
1683
|
+
@_builtins.property
|
|
1610
1684
|
@pulumi.getter
|
|
1611
|
-
def unit(self) -> pulumi.Input[str]:
|
|
1685
|
+
def unit(self) -> pulumi.Input[_builtins.str]:
|
|
1612
1686
|
return pulumi.get(self, "unit")
|
|
1613
1687
|
|
|
1614
1688
|
@unit.setter
|
|
1615
|
-
def unit(self, value: pulumi.Input[str]):
|
|
1689
|
+
def unit(self, value: pulumi.Input[_builtins.str]):
|
|
1616
1690
|
pulumi.set(self, "unit", value)
|
|
1617
1691
|
|
|
1618
|
-
@property
|
|
1692
|
+
@_builtins.property
|
|
1619
1693
|
@pulumi.getter(name="actionType")
|
|
1620
|
-
def action_type(self) -> Optional[pulumi.Input[str]]:
|
|
1694
|
+
def action_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1621
1695
|
"""
|
|
1622
1696
|
Type of scaling action to take when the scaling policy is triggered. Valid values: "adjustment", "setMinTarget", "updateCapacity", "percentageAdjustment"
|
|
1623
1697
|
"""
|
|
1624
1698
|
return pulumi.get(self, "action_type")
|
|
1625
1699
|
|
|
1626
1700
|
@action_type.setter
|
|
1627
|
-
def action_type(self, value: Optional[pulumi.Input[str]]):
|
|
1701
|
+
def action_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1628
1702
|
pulumi.set(self, "action_type", value)
|
|
1629
1703
|
|
|
1630
|
-
@property
|
|
1704
|
+
@_builtins.property
|
|
1631
1705
|
@pulumi.getter
|
|
1632
|
-
def adjustment(self) -> Optional[pulumi.Input[int]]:
|
|
1706
|
+
def adjustment(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1633
1707
|
"""
|
|
1634
1708
|
Value to which the action type will be adjusted. Required if using "numeric" or "percentageAdjustment" action types.
|
|
1635
1709
|
"""
|
|
1636
1710
|
return pulumi.get(self, "adjustment")
|
|
1637
1711
|
|
|
1638
1712
|
@adjustment.setter
|
|
1639
|
-
def adjustment(self, value: Optional[pulumi.Input[int]]):
|
|
1713
|
+
def adjustment(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1640
1714
|
pulumi.set(self, "adjustment", value)
|
|
1641
1715
|
|
|
1642
|
-
@property
|
|
1716
|
+
@_builtins.property
|
|
1643
1717
|
@pulumi.getter
|
|
1644
|
-
def cooldown(self) -> Optional[pulumi.Input[int]]:
|
|
1718
|
+
def cooldown(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1645
1719
|
"""
|
|
1646
1720
|
Time (seconds) to wait after a scaling action before resuming monitoring.
|
|
1647
1721
|
"""
|
|
1648
1722
|
return pulumi.get(self, "cooldown")
|
|
1649
1723
|
|
|
1650
1724
|
@cooldown.setter
|
|
1651
|
-
def cooldown(self, value: Optional[pulumi.Input[int]]):
|
|
1725
|
+
def cooldown(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1652
1726
|
pulumi.set(self, "cooldown", value)
|
|
1653
1727
|
|
|
1654
|
-
@property
|
|
1728
|
+
@_builtins.property
|
|
1655
1729
|
@pulumi.getter
|
|
1656
1730
|
def dimensions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingUpPolicyDimensionArgs']]]]:
|
|
1657
1731
|
"""
|
|
@@ -1663,74 +1737,74 @@ class ElastigroupScalingUpPolicyArgs:
|
|
|
1663
1737
|
def dimensions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingUpPolicyDimensionArgs']]]]):
|
|
1664
1738
|
pulumi.set(self, "dimensions", value)
|
|
1665
1739
|
|
|
1666
|
-
@property
|
|
1740
|
+
@_builtins.property
|
|
1667
1741
|
@pulumi.getter(name="evaluationPeriods")
|
|
1668
|
-
def evaluation_periods(self) -> Optional[pulumi.Input[int]]:
|
|
1742
|
+
def evaluation_periods(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1669
1743
|
"""
|
|
1670
1744
|
Number of consecutive periods in which the threshold must be met in order to trigger a scaling action.
|
|
1671
1745
|
"""
|
|
1672
1746
|
return pulumi.get(self, "evaluation_periods")
|
|
1673
1747
|
|
|
1674
1748
|
@evaluation_periods.setter
|
|
1675
|
-
def evaluation_periods(self, value: Optional[pulumi.Input[int]]):
|
|
1749
|
+
def evaluation_periods(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1676
1750
|
pulumi.set(self, "evaluation_periods", value)
|
|
1677
1751
|
|
|
1678
|
-
@property
|
|
1752
|
+
@_builtins.property
|
|
1679
1753
|
@pulumi.getter
|
|
1680
|
-
def operator(self) -> Optional[pulumi.Input[str]]:
|
|
1754
|
+
def operator(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1681
1755
|
"""
|
|
1682
1756
|
The operator used to evaluate the threshold against the current metric value. Valid values: "gt" (greater than), "get" (greater-than or equal), "lt" (less than), "lte" (less than or equal).
|
|
1683
1757
|
"""
|
|
1684
1758
|
return pulumi.get(self, "operator")
|
|
1685
1759
|
|
|
1686
1760
|
@operator.setter
|
|
1687
|
-
def operator(self, value: Optional[pulumi.Input[str]]):
|
|
1761
|
+
def operator(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1688
1762
|
pulumi.set(self, "operator", value)
|
|
1689
1763
|
|
|
1690
|
-
@property
|
|
1764
|
+
@_builtins.property
|
|
1691
1765
|
@pulumi.getter
|
|
1692
|
-
def period(self) -> Optional[pulumi.Input[int]]:
|
|
1766
|
+
def period(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1693
1767
|
"""
|
|
1694
1768
|
Amount of time (seconds) for which the threshold must be met in order to trigger the scaling action.
|
|
1695
1769
|
"""
|
|
1696
1770
|
return pulumi.get(self, "period")
|
|
1697
1771
|
|
|
1698
1772
|
@period.setter
|
|
1699
|
-
def period(self, value: Optional[pulumi.Input[int]]):
|
|
1773
|
+
def period(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1700
1774
|
pulumi.set(self, "period", value)
|
|
1701
1775
|
|
|
1702
|
-
@property
|
|
1776
|
+
@_builtins.property
|
|
1703
1777
|
@pulumi.getter
|
|
1704
|
-
def source(self) -> Optional[pulumi.Input[str]]:
|
|
1778
|
+
def source(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1705
1779
|
"""
|
|
1706
1780
|
Specifies a valid partial or full URL to an existing Persistent Disk resource. This field is only applicable for persistent disks.
|
|
1707
1781
|
"""
|
|
1708
1782
|
return pulumi.get(self, "source")
|
|
1709
1783
|
|
|
1710
1784
|
@source.setter
|
|
1711
|
-
def source(self, value: Optional[pulumi.Input[str]]):
|
|
1785
|
+
def source(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1712
1786
|
pulumi.set(self, "source", value)
|
|
1713
1787
|
|
|
1714
|
-
@property
|
|
1788
|
+
@_builtins.property
|
|
1715
1789
|
@pulumi.getter
|
|
1716
|
-
def statistic(self) -> Optional[pulumi.Input[str]]:
|
|
1790
|
+
def statistic(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1717
1791
|
"""
|
|
1718
1792
|
Statistic by which to evaluate the selected metric. Valid values: "AVERAGE", "SAMPLE_COUNT", "SUM", "MINIMUM", "MAXIMUM", "PERCENTILE", "COUNT".
|
|
1719
1793
|
"""
|
|
1720
1794
|
return pulumi.get(self, "statistic")
|
|
1721
1795
|
|
|
1722
1796
|
@statistic.setter
|
|
1723
|
-
def statistic(self, value: Optional[pulumi.Input[str]]):
|
|
1797
|
+
def statistic(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1724
1798
|
pulumi.set(self, "statistic", value)
|
|
1725
1799
|
|
|
1726
1800
|
|
|
1727
1801
|
if not MYPY:
|
|
1728
1802
|
class ElastigroupScalingUpPolicyDimensionArgsDict(TypedDict):
|
|
1729
|
-
name: pulumi.Input[str]
|
|
1803
|
+
name: pulumi.Input[_builtins.str]
|
|
1730
1804
|
"""
|
|
1731
1805
|
The dimension name.
|
|
1732
1806
|
"""
|
|
1733
|
-
value: NotRequired[pulumi.Input[str]]
|
|
1807
|
+
value: NotRequired[pulumi.Input[_builtins.str]]
|
|
1734
1808
|
"""
|
|
1735
1809
|
The dimension value.
|
|
1736
1810
|
|
|
@@ -1742,11 +1816,11 @@ elif False:
|
|
|
1742
1816
|
@pulumi.input_type
|
|
1743
1817
|
class ElastigroupScalingUpPolicyDimensionArgs:
|
|
1744
1818
|
def __init__(__self__, *,
|
|
1745
|
-
name: pulumi.Input[str],
|
|
1746
|
-
value: Optional[pulumi.Input[str]] = None):
|
|
1819
|
+
name: pulumi.Input[_builtins.str],
|
|
1820
|
+
value: Optional[pulumi.Input[_builtins.str]] = None):
|
|
1747
1821
|
"""
|
|
1748
|
-
:param pulumi.Input[str] name: The dimension name.
|
|
1749
|
-
:param pulumi.Input[str] value: The dimension value.
|
|
1822
|
+
:param pulumi.Input[_builtins.str] name: The dimension name.
|
|
1823
|
+
:param pulumi.Input[_builtins.str] value: The dimension value.
|
|
1750
1824
|
|
|
1751
1825
|
Usage:
|
|
1752
1826
|
"""
|
|
@@ -1754,21 +1828,21 @@ class ElastigroupScalingUpPolicyDimensionArgs:
|
|
|
1754
1828
|
if value is not None:
|
|
1755
1829
|
pulumi.set(__self__, "value", value)
|
|
1756
1830
|
|
|
1757
|
-
@property
|
|
1831
|
+
@_builtins.property
|
|
1758
1832
|
@pulumi.getter
|
|
1759
|
-
def name(self) -> pulumi.Input[str]:
|
|
1833
|
+
def name(self) -> pulumi.Input[_builtins.str]:
|
|
1760
1834
|
"""
|
|
1761
1835
|
The dimension name.
|
|
1762
1836
|
"""
|
|
1763
1837
|
return pulumi.get(self, "name")
|
|
1764
1838
|
|
|
1765
1839
|
@name.setter
|
|
1766
|
-
def name(self, value: pulumi.Input[str]):
|
|
1840
|
+
def name(self, value: pulumi.Input[_builtins.str]):
|
|
1767
1841
|
pulumi.set(self, "name", value)
|
|
1768
1842
|
|
|
1769
|
-
@property
|
|
1843
|
+
@_builtins.property
|
|
1770
1844
|
@pulumi.getter
|
|
1771
|
-
def value(self) -> Optional[pulumi.Input[str]]:
|
|
1845
|
+
def value(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1772
1846
|
"""
|
|
1773
1847
|
The dimension value.
|
|
1774
1848
|
|
|
@@ -1777,35 +1851,35 @@ class ElastigroupScalingUpPolicyDimensionArgs:
|
|
|
1777
1851
|
return pulumi.get(self, "value")
|
|
1778
1852
|
|
|
1779
1853
|
@value.setter
|
|
1780
|
-
def value(self, value: Optional[pulumi.Input[str]]):
|
|
1854
|
+
def value(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1781
1855
|
pulumi.set(self, "value", value)
|
|
1782
1856
|
|
|
1783
1857
|
|
|
1784
1858
|
if not MYPY:
|
|
1785
1859
|
class ElastigroupScheduledTaskArgsDict(TypedDict):
|
|
1786
|
-
task_type: pulumi.Input[str]
|
|
1860
|
+
task_type: pulumi.Input[_builtins.str]
|
|
1787
1861
|
"""
|
|
1788
1862
|
The task type to run. Valid values: `"setCapacity"`.
|
|
1789
1863
|
"""
|
|
1790
|
-
cron_expression: NotRequired[pulumi.Input[str]]
|
|
1864
|
+
cron_expression: NotRequired[pulumi.Input[_builtins.str]]
|
|
1791
1865
|
"""
|
|
1792
1866
|
A valid cron expression. The cron is running in UTC time zone and is in [Unix cron format](https://en.wikipedia.org/wiki/Cron).
|
|
1793
1867
|
"""
|
|
1794
|
-
is_enabled: NotRequired[pulumi.Input[bool]]
|
|
1868
|
+
is_enabled: NotRequired[pulumi.Input[_builtins.bool]]
|
|
1795
1869
|
"""
|
|
1796
1870
|
Setting the task to being enabled or disabled.
|
|
1797
1871
|
"""
|
|
1798
|
-
max_capacity: NotRequired[pulumi.Input[str]]
|
|
1872
|
+
max_capacity: NotRequired[pulumi.Input[_builtins.str]]
|
|
1799
1873
|
"""
|
|
1800
1874
|
The maximum number of instances the group should have.
|
|
1801
1875
|
|
|
1802
1876
|
Usage:
|
|
1803
1877
|
"""
|
|
1804
|
-
min_capacity: NotRequired[pulumi.Input[str]]
|
|
1878
|
+
min_capacity: NotRequired[pulumi.Input[_builtins.str]]
|
|
1805
1879
|
"""
|
|
1806
1880
|
The minimum number of instances the group should have.
|
|
1807
1881
|
"""
|
|
1808
|
-
target_capacity: NotRequired[pulumi.Input[str]]
|
|
1882
|
+
target_capacity: NotRequired[pulumi.Input[_builtins.str]]
|
|
1809
1883
|
"""
|
|
1810
1884
|
The desired number of instances the group should have.
|
|
1811
1885
|
"""
|
|
@@ -1815,21 +1889,21 @@ elif False:
|
|
|
1815
1889
|
@pulumi.input_type
|
|
1816
1890
|
class ElastigroupScheduledTaskArgs:
|
|
1817
1891
|
def __init__(__self__, *,
|
|
1818
|
-
task_type: pulumi.Input[str],
|
|
1819
|
-
cron_expression: Optional[pulumi.Input[str]] = None,
|
|
1820
|
-
is_enabled: Optional[pulumi.Input[bool]] = None,
|
|
1821
|
-
max_capacity: Optional[pulumi.Input[str]] = None,
|
|
1822
|
-
min_capacity: Optional[pulumi.Input[str]] = None,
|
|
1823
|
-
target_capacity: Optional[pulumi.Input[str]] = None):
|
|
1824
|
-
"""
|
|
1825
|
-
:param pulumi.Input[str] task_type: The task type to run. Valid values: `"setCapacity"`.
|
|
1826
|
-
:param pulumi.Input[str] cron_expression: A valid cron expression. The cron is running in UTC time zone and is in [Unix cron format](https://en.wikipedia.org/wiki/Cron).
|
|
1827
|
-
:param pulumi.Input[bool] is_enabled: Setting the task to being enabled or disabled.
|
|
1828
|
-
:param pulumi.Input[str] max_capacity: The maximum number of instances the group should have.
|
|
1892
|
+
task_type: pulumi.Input[_builtins.str],
|
|
1893
|
+
cron_expression: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1894
|
+
is_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1895
|
+
max_capacity: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1896
|
+
min_capacity: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1897
|
+
target_capacity: Optional[pulumi.Input[_builtins.str]] = None):
|
|
1898
|
+
"""
|
|
1899
|
+
:param pulumi.Input[_builtins.str] task_type: The task type to run. Valid values: `"setCapacity"`.
|
|
1900
|
+
: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](https://en.wikipedia.org/wiki/Cron).
|
|
1901
|
+
:param pulumi.Input[_builtins.bool] is_enabled: Setting the task to being enabled or disabled.
|
|
1902
|
+
:param pulumi.Input[_builtins.str] max_capacity: The maximum number of instances the group should have.
|
|
1829
1903
|
|
|
1830
1904
|
Usage:
|
|
1831
|
-
:param pulumi.Input[str] min_capacity: The minimum number of instances the group should have.
|
|
1832
|
-
:param pulumi.Input[str] target_capacity: The desired number of instances the group should have.
|
|
1905
|
+
:param pulumi.Input[_builtins.str] min_capacity: The minimum number of instances the group should have.
|
|
1906
|
+
:param pulumi.Input[_builtins.str] target_capacity: The desired number of instances the group should have.
|
|
1833
1907
|
"""
|
|
1834
1908
|
pulumi.set(__self__, "task_type", task_type)
|
|
1835
1909
|
if cron_expression is not None:
|
|
@@ -1843,45 +1917,45 @@ class ElastigroupScheduledTaskArgs:
|
|
|
1843
1917
|
if target_capacity is not None:
|
|
1844
1918
|
pulumi.set(__self__, "target_capacity", target_capacity)
|
|
1845
1919
|
|
|
1846
|
-
@property
|
|
1920
|
+
@_builtins.property
|
|
1847
1921
|
@pulumi.getter(name="taskType")
|
|
1848
|
-
def task_type(self) -> pulumi.Input[str]:
|
|
1922
|
+
def task_type(self) -> pulumi.Input[_builtins.str]:
|
|
1849
1923
|
"""
|
|
1850
1924
|
The task type to run. Valid values: `"setCapacity"`.
|
|
1851
1925
|
"""
|
|
1852
1926
|
return pulumi.get(self, "task_type")
|
|
1853
1927
|
|
|
1854
1928
|
@task_type.setter
|
|
1855
|
-
def task_type(self, value: pulumi.Input[str]):
|
|
1929
|
+
def task_type(self, value: pulumi.Input[_builtins.str]):
|
|
1856
1930
|
pulumi.set(self, "task_type", value)
|
|
1857
1931
|
|
|
1858
|
-
@property
|
|
1932
|
+
@_builtins.property
|
|
1859
1933
|
@pulumi.getter(name="cronExpression")
|
|
1860
|
-
def cron_expression(self) -> Optional[pulumi.Input[str]]:
|
|
1934
|
+
def cron_expression(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1861
1935
|
"""
|
|
1862
1936
|
A valid cron expression. The cron is running in UTC time zone and is in [Unix cron format](https://en.wikipedia.org/wiki/Cron).
|
|
1863
1937
|
"""
|
|
1864
1938
|
return pulumi.get(self, "cron_expression")
|
|
1865
1939
|
|
|
1866
1940
|
@cron_expression.setter
|
|
1867
|
-
def cron_expression(self, value: Optional[pulumi.Input[str]]):
|
|
1941
|
+
def cron_expression(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1868
1942
|
pulumi.set(self, "cron_expression", value)
|
|
1869
1943
|
|
|
1870
|
-
@property
|
|
1944
|
+
@_builtins.property
|
|
1871
1945
|
@pulumi.getter(name="isEnabled")
|
|
1872
|
-
def is_enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
1946
|
+
def is_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1873
1947
|
"""
|
|
1874
1948
|
Setting the task to being enabled or disabled.
|
|
1875
1949
|
"""
|
|
1876
1950
|
return pulumi.get(self, "is_enabled")
|
|
1877
1951
|
|
|
1878
1952
|
@is_enabled.setter
|
|
1879
|
-
def is_enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
1953
|
+
def is_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1880
1954
|
pulumi.set(self, "is_enabled", value)
|
|
1881
1955
|
|
|
1882
|
-
@property
|
|
1956
|
+
@_builtins.property
|
|
1883
1957
|
@pulumi.getter(name="maxCapacity")
|
|
1884
|
-
def max_capacity(self) -> Optional[pulumi.Input[str]]:
|
|
1958
|
+
def max_capacity(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1885
1959
|
"""
|
|
1886
1960
|
The maximum number of instances the group should have.
|
|
1887
1961
|
|
|
@@ -1890,41 +1964,41 @@ class ElastigroupScheduledTaskArgs:
|
|
|
1890
1964
|
return pulumi.get(self, "max_capacity")
|
|
1891
1965
|
|
|
1892
1966
|
@max_capacity.setter
|
|
1893
|
-
def max_capacity(self, value: Optional[pulumi.Input[str]]):
|
|
1967
|
+
def max_capacity(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1894
1968
|
pulumi.set(self, "max_capacity", value)
|
|
1895
1969
|
|
|
1896
|
-
@property
|
|
1970
|
+
@_builtins.property
|
|
1897
1971
|
@pulumi.getter(name="minCapacity")
|
|
1898
|
-
def min_capacity(self) -> Optional[pulumi.Input[str]]:
|
|
1972
|
+
def min_capacity(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1899
1973
|
"""
|
|
1900
1974
|
The minimum number of instances the group should have.
|
|
1901
1975
|
"""
|
|
1902
1976
|
return pulumi.get(self, "min_capacity")
|
|
1903
1977
|
|
|
1904
1978
|
@min_capacity.setter
|
|
1905
|
-
def min_capacity(self, value: Optional[pulumi.Input[str]]):
|
|
1979
|
+
def min_capacity(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1906
1980
|
pulumi.set(self, "min_capacity", value)
|
|
1907
1981
|
|
|
1908
|
-
@property
|
|
1982
|
+
@_builtins.property
|
|
1909
1983
|
@pulumi.getter(name="targetCapacity")
|
|
1910
|
-
def target_capacity(self) -> Optional[pulumi.Input[str]]:
|
|
1984
|
+
def target_capacity(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1911
1985
|
"""
|
|
1912
1986
|
The desired number of instances the group should have.
|
|
1913
1987
|
"""
|
|
1914
1988
|
return pulumi.get(self, "target_capacity")
|
|
1915
1989
|
|
|
1916
1990
|
@target_capacity.setter
|
|
1917
|
-
def target_capacity(self, value: Optional[pulumi.Input[str]]):
|
|
1991
|
+
def target_capacity(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1918
1992
|
pulumi.set(self, "target_capacity", value)
|
|
1919
1993
|
|
|
1920
1994
|
|
|
1921
1995
|
if not MYPY:
|
|
1922
1996
|
class ElastigroupShieldedInstanceConfigArgsDict(TypedDict):
|
|
1923
|
-
enable_integrity_monitoring: NotRequired[pulumi.Input[bool]]
|
|
1997
|
+
enable_integrity_monitoring: NotRequired[pulumi.Input[_builtins.bool]]
|
|
1924
1998
|
"""
|
|
1925
1999
|
Default: false
|
|
1926
2000
|
"""
|
|
1927
|
-
enable_secure_boot: NotRequired[pulumi.Input[bool]]
|
|
2001
|
+
enable_secure_boot: NotRequired[pulumi.Input[_builtins.bool]]
|
|
1928
2002
|
"""
|
|
1929
2003
|
Default: false
|
|
1930
2004
|
"""
|
|
@@ -1934,49 +2008,49 @@ elif False:
|
|
|
1934
2008
|
@pulumi.input_type
|
|
1935
2009
|
class ElastigroupShieldedInstanceConfigArgs:
|
|
1936
2010
|
def __init__(__self__, *,
|
|
1937
|
-
enable_integrity_monitoring: Optional[pulumi.Input[bool]] = None,
|
|
1938
|
-
enable_secure_boot: Optional[pulumi.Input[bool]] = None):
|
|
2011
|
+
enable_integrity_monitoring: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
2012
|
+
enable_secure_boot: Optional[pulumi.Input[_builtins.bool]] = None):
|
|
1939
2013
|
"""
|
|
1940
|
-
:param pulumi.Input[bool] enable_integrity_monitoring: Default: false
|
|
1941
|
-
:param pulumi.Input[bool] enable_secure_boot: Default: false
|
|
2014
|
+
:param pulumi.Input[_builtins.bool] enable_integrity_monitoring: Default: false
|
|
2015
|
+
:param pulumi.Input[_builtins.bool] enable_secure_boot: Default: false
|
|
1942
2016
|
"""
|
|
1943
2017
|
if enable_integrity_monitoring is not None:
|
|
1944
2018
|
pulumi.set(__self__, "enable_integrity_monitoring", enable_integrity_monitoring)
|
|
1945
2019
|
if enable_secure_boot is not None:
|
|
1946
2020
|
pulumi.set(__self__, "enable_secure_boot", enable_secure_boot)
|
|
1947
2021
|
|
|
1948
|
-
@property
|
|
2022
|
+
@_builtins.property
|
|
1949
2023
|
@pulumi.getter(name="enableIntegrityMonitoring")
|
|
1950
|
-
def enable_integrity_monitoring(self) -> Optional[pulumi.Input[bool]]:
|
|
2024
|
+
def enable_integrity_monitoring(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1951
2025
|
"""
|
|
1952
2026
|
Default: false
|
|
1953
2027
|
"""
|
|
1954
2028
|
return pulumi.get(self, "enable_integrity_monitoring")
|
|
1955
2029
|
|
|
1956
2030
|
@enable_integrity_monitoring.setter
|
|
1957
|
-
def enable_integrity_monitoring(self, value: Optional[pulumi.Input[bool]]):
|
|
2031
|
+
def enable_integrity_monitoring(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1958
2032
|
pulumi.set(self, "enable_integrity_monitoring", value)
|
|
1959
2033
|
|
|
1960
|
-
@property
|
|
2034
|
+
@_builtins.property
|
|
1961
2035
|
@pulumi.getter(name="enableSecureBoot")
|
|
1962
|
-
def enable_secure_boot(self) -> Optional[pulumi.Input[bool]]:
|
|
2036
|
+
def enable_secure_boot(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1963
2037
|
"""
|
|
1964
2038
|
Default: false
|
|
1965
2039
|
"""
|
|
1966
2040
|
return pulumi.get(self, "enable_secure_boot")
|
|
1967
2041
|
|
|
1968
2042
|
@enable_secure_boot.setter
|
|
1969
|
-
def enable_secure_boot(self, value: Optional[pulumi.Input[bool]]):
|
|
2043
|
+
def enable_secure_boot(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1970
2044
|
pulumi.set(self, "enable_secure_boot", value)
|
|
1971
2045
|
|
|
1972
2046
|
|
|
1973
2047
|
if not MYPY:
|
|
1974
2048
|
class ElastigroupSubnetArgsDict(TypedDict):
|
|
1975
|
-
region: pulumi.Input[str]
|
|
2049
|
+
region: pulumi.Input[_builtins.str]
|
|
1976
2050
|
"""
|
|
1977
2051
|
The region for the group of subnets.
|
|
1978
2052
|
"""
|
|
1979
|
-
subnet_names: pulumi.Input[Sequence[pulumi.Input[str]]]
|
|
2053
|
+
subnet_names: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]
|
|
1980
2054
|
"""
|
|
1981
2055
|
The names of the subnets in the region.
|
|
1982
2056
|
"""
|
|
@@ -1986,37 +2060,37 @@ elif False:
|
|
|
1986
2060
|
@pulumi.input_type
|
|
1987
2061
|
class ElastigroupSubnetArgs:
|
|
1988
2062
|
def __init__(__self__, *,
|
|
1989
|
-
region: pulumi.Input[str],
|
|
1990
|
-
subnet_names: pulumi.Input[Sequence[pulumi.Input[str]]]):
|
|
2063
|
+
region: pulumi.Input[_builtins.str],
|
|
2064
|
+
subnet_names: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]):
|
|
1991
2065
|
"""
|
|
1992
|
-
:param pulumi.Input[str] region: The region for the group of subnets.
|
|
1993
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] subnet_names: The names of the subnets in the region.
|
|
2066
|
+
:param pulumi.Input[_builtins.str] region: The region for the group of subnets.
|
|
2067
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] subnet_names: The names of the subnets in the region.
|
|
1994
2068
|
"""
|
|
1995
2069
|
pulumi.set(__self__, "region", region)
|
|
1996
2070
|
pulumi.set(__self__, "subnet_names", subnet_names)
|
|
1997
2071
|
|
|
1998
|
-
@property
|
|
2072
|
+
@_builtins.property
|
|
1999
2073
|
@pulumi.getter
|
|
2000
|
-
def region(self) -> pulumi.Input[str]:
|
|
2074
|
+
def region(self) -> pulumi.Input[_builtins.str]:
|
|
2001
2075
|
"""
|
|
2002
2076
|
The region for the group of subnets.
|
|
2003
2077
|
"""
|
|
2004
2078
|
return pulumi.get(self, "region")
|
|
2005
2079
|
|
|
2006
2080
|
@region.setter
|
|
2007
|
-
def region(self, value: pulumi.Input[str]):
|
|
2081
|
+
def region(self, value: pulumi.Input[_builtins.str]):
|
|
2008
2082
|
pulumi.set(self, "region", value)
|
|
2009
2083
|
|
|
2010
|
-
@property
|
|
2084
|
+
@_builtins.property
|
|
2011
2085
|
@pulumi.getter(name="subnetNames")
|
|
2012
|
-
def subnet_names(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
|
|
2086
|
+
def subnet_names(self) -> pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]:
|
|
2013
2087
|
"""
|
|
2014
2088
|
The names of the subnets in the region.
|
|
2015
2089
|
"""
|
|
2016
2090
|
return pulumi.get(self, "subnet_names")
|
|
2017
2091
|
|
|
2018
2092
|
@subnet_names.setter
|
|
2019
|
-
def subnet_names(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
|
|
2093
|
+
def subnet_names(self, value: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]):
|
|
2020
2094
|
pulumi.set(self, "subnet_names", value)
|
|
2021
2095
|
|
|
2022
2096
|
|