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