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