pulumi-nomad 2.3.0a1710649436__py3-none-any.whl → 2.5.0a1736834448__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_nomad/__init__.py +1 -0
- pulumi_nomad/_inputs.py +896 -175
- pulumi_nomad/_utilities.py +41 -5
- pulumi_nomad/acl_auth_method.py +44 -41
- pulumi_nomad/acl_binding_rule.py +5 -0
- pulumi_nomad/acl_policy.py +10 -69
- pulumi_nomad/acl_role.py +10 -5
- pulumi_nomad/acl_token.py +28 -31
- pulumi_nomad/config/__init__.pyi +5 -0
- pulumi_nomad/config/outputs.py +5 -0
- pulumi_nomad/config/vars.py +5 -0
- pulumi_nomad/csi_volume.py +21 -88
- pulumi_nomad/csi_volume_registration.py +21 -88
- pulumi_nomad/external_volume.py +65 -132
- pulumi_nomad/get_acl_policies.py +14 -9
- pulumi_nomad/get_acl_policy.py +15 -9
- pulumi_nomad/get_acl_role.py +15 -9
- pulumi_nomad/get_acl_roles.py +14 -9
- pulumi_nomad/get_acl_token.py +22 -9
- pulumi_nomad/get_acl_tokens.py +14 -9
- pulumi_nomad/get_allocations.py +18 -9
- pulumi_nomad/get_datacenters.py +20 -13
- pulumi_nomad/get_deployments.py +18 -10
- pulumi_nomad/get_job.py +34 -9
- pulumi_nomad/get_job_parser.py +16 -29
- pulumi_nomad/get_jwks.py +124 -0
- pulumi_nomad/get_namespace.py +18 -9
- pulumi_nomad/get_namespaces.py +14 -9
- pulumi_nomad/get_node_pool.py +16 -9
- pulumi_nomad/get_node_pools.py +16 -9
- pulumi_nomad/get_plugin.py +25 -9
- pulumi_nomad/get_plugins.py +15 -10
- pulumi_nomad/get_regions.py +46 -5
- pulumi_nomad/get_scaling_policies.py +16 -9
- pulumi_nomad/get_scaling_policy.py +19 -10
- pulumi_nomad/get_scheduler_policy.py +14 -9
- pulumi_nomad/get_variable.py +17 -10
- pulumi_nomad/get_volumes.py +21 -10
- pulumi_nomad/job.py +22 -88
- pulumi_nomad/namespace.py +43 -40
- pulumi_nomad/node_pool.py +12 -9
- pulumi_nomad/outputs.py +293 -165
- pulumi_nomad/provider.py +8 -3
- pulumi_nomad/pulumi-plugin.json +2 -1
- pulumi_nomad/quote_specification.py +28 -25
- pulumi_nomad/scheduler_config.py +11 -10
- pulumi_nomad/sentinel_policy.py +11 -10
- pulumi_nomad/variable.py +33 -32
- pulumi_nomad/volume.py +73 -152
- {pulumi_nomad-2.3.0a1710649436.dist-info → pulumi_nomad-2.5.0a1736834448.dist-info}/METADATA +7 -6
- pulumi_nomad-2.5.0a1736834448.dist-info/RECORD +55 -0
- {pulumi_nomad-2.3.0a1710649436.dist-info → pulumi_nomad-2.5.0a1736834448.dist-info}/WHEEL +1 -1
- pulumi_nomad-2.3.0a1710649436.dist-info/RECORD +0 -54
- {pulumi_nomad-2.3.0a1710649436.dist-info → pulumi_nomad-2.5.0a1736834448.dist-info}/top_level.txt +0 -0
pulumi_nomad/_inputs.py
CHANGED
|
@@ -4,110 +4,291 @@
|
|
|
4
4
|
|
|
5
5
|
import copy
|
|
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
|
'AclAuthMethodConfigArgs',
|
|
19
|
+
'AclAuthMethodConfigArgsDict',
|
|
14
20
|
'AclPolicyJobAclArgs',
|
|
21
|
+
'AclPolicyJobAclArgsDict',
|
|
15
22
|
'AclRolePolicyArgs',
|
|
23
|
+
'AclRolePolicyArgsDict',
|
|
16
24
|
'AclTokenRoleArgs',
|
|
25
|
+
'AclTokenRoleArgsDict',
|
|
17
26
|
'CsiVolumeCapabilityArgs',
|
|
27
|
+
'CsiVolumeCapabilityArgsDict',
|
|
18
28
|
'CsiVolumeMountOptionsArgs',
|
|
29
|
+
'CsiVolumeMountOptionsArgsDict',
|
|
19
30
|
'CsiVolumeRegistrationCapabilityArgs',
|
|
31
|
+
'CsiVolumeRegistrationCapabilityArgsDict',
|
|
20
32
|
'CsiVolumeRegistrationMountOptionsArgs',
|
|
33
|
+
'CsiVolumeRegistrationMountOptionsArgsDict',
|
|
21
34
|
'CsiVolumeRegistrationTopologyArgs',
|
|
35
|
+
'CsiVolumeRegistrationTopologyArgsDict',
|
|
22
36
|
'CsiVolumeRegistrationTopologyRequestArgs',
|
|
37
|
+
'CsiVolumeRegistrationTopologyRequestArgsDict',
|
|
23
38
|
'CsiVolumeRegistrationTopologyRequestRequiredArgs',
|
|
39
|
+
'CsiVolumeRegistrationTopologyRequestRequiredArgsDict',
|
|
24
40
|
'CsiVolumeRegistrationTopologyRequestRequiredTopologyArgs',
|
|
41
|
+
'CsiVolumeRegistrationTopologyRequestRequiredTopologyArgsDict',
|
|
25
42
|
'CsiVolumeTopologyArgs',
|
|
43
|
+
'CsiVolumeTopologyArgsDict',
|
|
26
44
|
'CsiVolumeTopologyRequestArgs',
|
|
45
|
+
'CsiVolumeTopologyRequestArgsDict',
|
|
27
46
|
'CsiVolumeTopologyRequestPreferredArgs',
|
|
47
|
+
'CsiVolumeTopologyRequestPreferredArgsDict',
|
|
28
48
|
'CsiVolumeTopologyRequestPreferredTopologyArgs',
|
|
49
|
+
'CsiVolumeTopologyRequestPreferredTopologyArgsDict',
|
|
29
50
|
'CsiVolumeTopologyRequestRequiredArgs',
|
|
51
|
+
'CsiVolumeTopologyRequestRequiredArgsDict',
|
|
30
52
|
'CsiVolumeTopologyRequestRequiredTopologyArgs',
|
|
53
|
+
'CsiVolumeTopologyRequestRequiredTopologyArgsDict',
|
|
31
54
|
'ExternalVolumeCapabilityArgs',
|
|
55
|
+
'ExternalVolumeCapabilityArgsDict',
|
|
32
56
|
'ExternalVolumeMountOptionsArgs',
|
|
57
|
+
'ExternalVolumeMountOptionsArgsDict',
|
|
33
58
|
'ExternalVolumeTopologyArgs',
|
|
59
|
+
'ExternalVolumeTopologyArgsDict',
|
|
34
60
|
'ExternalVolumeTopologyRequestArgs',
|
|
61
|
+
'ExternalVolumeTopologyRequestArgsDict',
|
|
35
62
|
'ExternalVolumeTopologyRequestPreferredArgs',
|
|
63
|
+
'ExternalVolumeTopologyRequestPreferredArgsDict',
|
|
36
64
|
'ExternalVolumeTopologyRequestPreferredTopologyArgs',
|
|
65
|
+
'ExternalVolumeTopologyRequestPreferredTopologyArgsDict',
|
|
37
66
|
'ExternalVolumeTopologyRequestRequiredArgs',
|
|
67
|
+
'ExternalVolumeTopologyRequestRequiredArgsDict',
|
|
38
68
|
'ExternalVolumeTopologyRequestRequiredTopologyArgs',
|
|
69
|
+
'ExternalVolumeTopologyRequestRequiredTopologyArgsDict',
|
|
39
70
|
'JobHcl2Args',
|
|
71
|
+
'JobHcl2ArgsDict',
|
|
40
72
|
'JobTaskGroupArgs',
|
|
73
|
+
'JobTaskGroupArgsDict',
|
|
41
74
|
'JobTaskGroupTaskArgs',
|
|
75
|
+
'JobTaskGroupTaskArgsDict',
|
|
42
76
|
'JobTaskGroupTaskVolumeMountArgs',
|
|
77
|
+
'JobTaskGroupTaskVolumeMountArgsDict',
|
|
43
78
|
'JobTaskGroupVolumeArgs',
|
|
79
|
+
'JobTaskGroupVolumeArgsDict',
|
|
44
80
|
'NamespaceCapabilitiesArgs',
|
|
81
|
+
'NamespaceCapabilitiesArgsDict',
|
|
45
82
|
'NamespaceNodePoolConfigArgs',
|
|
83
|
+
'NamespaceNodePoolConfigArgsDict',
|
|
46
84
|
'NodePoolSchedulerConfigArgs',
|
|
85
|
+
'NodePoolSchedulerConfigArgsDict',
|
|
47
86
|
'ProviderHeaderArgs',
|
|
87
|
+
'ProviderHeaderArgsDict',
|
|
48
88
|
'QuoteSpecificationLimitArgs',
|
|
89
|
+
'QuoteSpecificationLimitArgsDict',
|
|
49
90
|
'QuoteSpecificationLimitRegionLimitArgs',
|
|
91
|
+
'QuoteSpecificationLimitRegionLimitArgsDict',
|
|
50
92
|
'VolumeCapabilityArgs',
|
|
93
|
+
'VolumeCapabilityArgsDict',
|
|
51
94
|
'VolumeMountOptionsArgs',
|
|
95
|
+
'VolumeMountOptionsArgsDict',
|
|
52
96
|
'VolumeTopologyArgs',
|
|
97
|
+
'VolumeTopologyArgsDict',
|
|
53
98
|
'VolumeTopologyRequestArgs',
|
|
99
|
+
'VolumeTopologyRequestArgsDict',
|
|
54
100
|
'VolumeTopologyRequestRequiredArgs',
|
|
101
|
+
'VolumeTopologyRequestRequiredArgsDict',
|
|
55
102
|
'VolumeTopologyRequestRequiredTopologyArgs',
|
|
103
|
+
'VolumeTopologyRequestRequiredTopologyArgsDict',
|
|
56
104
|
]
|
|
57
105
|
|
|
106
|
+
MYPY = False
|
|
107
|
+
|
|
108
|
+
if not MYPY:
|
|
109
|
+
class AclAuthMethodConfigArgsDict(TypedDict):
|
|
110
|
+
allowed_redirect_uris: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
111
|
+
"""
|
|
112
|
+
`([]string: <optional>)` - A list of allowed values
|
|
113
|
+
that can be used for the redirect URI.
|
|
114
|
+
"""
|
|
115
|
+
bound_audiences: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
116
|
+
"""
|
|
117
|
+
`([]string: <optional>)` - List of auth claims that are
|
|
118
|
+
valid for login.
|
|
119
|
+
"""
|
|
120
|
+
bound_issuers: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
121
|
+
"""
|
|
122
|
+
`([]string: <optional>)` - The value against which to match
|
|
123
|
+
the iss claim in a JWT.
|
|
124
|
+
"""
|
|
125
|
+
claim_mappings: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
126
|
+
"""
|
|
127
|
+
Mappings of claims (key) that will be copied to a metadata field (value).
|
|
128
|
+
"""
|
|
129
|
+
clock_skew_leeway: NotRequired[pulumi.Input[str]]
|
|
130
|
+
"""
|
|
131
|
+
`(string: <optional>)` - Duration of leeway when validating
|
|
132
|
+
all claims in the form of a time duration such as "5m" or "1h".
|
|
133
|
+
"""
|
|
134
|
+
discovery_ca_pems: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
135
|
+
"""
|
|
136
|
+
`([]string: <optional>)` - PEM encoded CA certs for use
|
|
137
|
+
by the TLS client used to talk with the OIDC Discovery URL.
|
|
138
|
+
"""
|
|
139
|
+
expiration_leeway: NotRequired[pulumi.Input[str]]
|
|
140
|
+
"""
|
|
141
|
+
`(string: <optional>)` - Duration of leeway when validating
|
|
142
|
+
expiration of a JWT in the form of a time duration such as "5m" or "1h".
|
|
143
|
+
"""
|
|
144
|
+
jwks_ca_cert: NotRequired[pulumi.Input[str]]
|
|
145
|
+
"""
|
|
146
|
+
`(string: <optional>)` - PEM encoded CA cert for use by the
|
|
147
|
+
TLS client used to talk with the JWKS server.
|
|
148
|
+
"""
|
|
149
|
+
jwks_url: NotRequired[pulumi.Input[str]]
|
|
150
|
+
"""
|
|
151
|
+
`(string: <optional>)` - JSON Web Key Sets url for authenticating
|
|
152
|
+
signatures.
|
|
153
|
+
"""
|
|
154
|
+
jwt_validation_pub_keys: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
155
|
+
"""
|
|
156
|
+
`([]string: <optional>)` - List of PEM-encoded
|
|
157
|
+
public keys to use to authenticate signatures locally.
|
|
158
|
+
"""
|
|
159
|
+
list_claim_mappings: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
160
|
+
"""
|
|
161
|
+
Mappings of list claims (key) that will be copied to a metadata field (value).
|
|
162
|
+
"""
|
|
163
|
+
not_before_leeway: NotRequired[pulumi.Input[str]]
|
|
164
|
+
"""
|
|
165
|
+
`(string: <optional>)` - Duration of leeway when validating
|
|
166
|
+
not before values of a token in the form of a time duration such as "5m" or "1h".
|
|
167
|
+
"""
|
|
168
|
+
oidc_client_id: NotRequired[pulumi.Input[str]]
|
|
169
|
+
"""
|
|
170
|
+
`(string: <optional>)` - The OAuth Client ID configured
|
|
171
|
+
with the OIDC provider.
|
|
172
|
+
"""
|
|
173
|
+
oidc_client_secret: NotRequired[pulumi.Input[str]]
|
|
174
|
+
"""
|
|
175
|
+
`(string: <optional>)` - The OAuth Client Secret
|
|
176
|
+
configured with the OIDC provider.
|
|
177
|
+
"""
|
|
178
|
+
oidc_disable_userinfo: NotRequired[pulumi.Input[bool]]
|
|
179
|
+
"""
|
|
180
|
+
`(bool: false)` - When set to `true`, Nomad will
|
|
181
|
+
not make a request to the identity provider to get OIDC `UserInfo`.
|
|
182
|
+
You may wish to set this if your identity provider doesn't send any
|
|
183
|
+
additional claims from the `UserInfo` endpoint.
|
|
184
|
+
"""
|
|
185
|
+
oidc_discovery_url: NotRequired[pulumi.Input[str]]
|
|
186
|
+
"""
|
|
187
|
+
`(string: <optional>)` - The OIDC Discovery URL,
|
|
188
|
+
without any .well-known component (base path).
|
|
189
|
+
"""
|
|
190
|
+
oidc_scopes: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
191
|
+
"""
|
|
192
|
+
`([]string: <optional>)` - List of OIDC scopes.
|
|
193
|
+
"""
|
|
194
|
+
signing_algs: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
195
|
+
"""
|
|
196
|
+
`([]string: <optional>)` - A list of supported signing
|
|
197
|
+
algorithms.
|
|
198
|
+
"""
|
|
199
|
+
elif False:
|
|
200
|
+
AclAuthMethodConfigArgsDict: TypeAlias = Mapping[str, Any]
|
|
201
|
+
|
|
58
202
|
@pulumi.input_type
|
|
59
203
|
class AclAuthMethodConfigArgs:
|
|
60
204
|
def __init__(__self__, *,
|
|
61
|
-
allowed_redirect_uris: pulumi.Input[Sequence[pulumi.Input[str]]],
|
|
62
|
-
oidc_client_id: pulumi.Input[str],
|
|
63
|
-
oidc_client_secret: pulumi.Input[str],
|
|
64
|
-
oidc_discovery_url: pulumi.Input[str],
|
|
205
|
+
allowed_redirect_uris: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
65
206
|
bound_audiences: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
207
|
+
bound_issuers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
66
208
|
claim_mappings: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
209
|
+
clock_skew_leeway: Optional[pulumi.Input[str]] = None,
|
|
67
210
|
discovery_ca_pems: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
211
|
+
expiration_leeway: Optional[pulumi.Input[str]] = None,
|
|
212
|
+
jwks_ca_cert: Optional[pulumi.Input[str]] = None,
|
|
213
|
+
jwks_url: Optional[pulumi.Input[str]] = None,
|
|
214
|
+
jwt_validation_pub_keys: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
68
215
|
list_claim_mappings: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
216
|
+
not_before_leeway: Optional[pulumi.Input[str]] = None,
|
|
217
|
+
oidc_client_id: Optional[pulumi.Input[str]] = None,
|
|
218
|
+
oidc_client_secret: Optional[pulumi.Input[str]] = None,
|
|
69
219
|
oidc_disable_userinfo: Optional[pulumi.Input[bool]] = None,
|
|
220
|
+
oidc_discovery_url: Optional[pulumi.Input[str]] = None,
|
|
70
221
|
oidc_scopes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
71
222
|
signing_algs: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
|
|
72
223
|
"""
|
|
73
224
|
:param pulumi.Input[Sequence[pulumi.Input[str]]] allowed_redirect_uris: `([]string: <optional>)` - A list of allowed values
|
|
74
225
|
that can be used for the redirect URI.
|
|
75
|
-
:param pulumi.Input[str] oidc_client_id: `(string: <required>)` - The OAuth Client ID configured
|
|
76
|
-
with the OIDC provider.
|
|
77
|
-
:param pulumi.Input[str] oidc_client_secret: `(string: <required>)` - The OAuth Client Secret
|
|
78
|
-
configured with the OIDC provider.
|
|
79
|
-
:param pulumi.Input[str] oidc_discovery_url: `(string: <required>)` - The OIDC Discovery URL,
|
|
80
|
-
without any .well-known component (base path).
|
|
81
226
|
:param pulumi.Input[Sequence[pulumi.Input[str]]] bound_audiences: `([]string: <optional>)` - List of auth claims that are
|
|
82
227
|
valid for login.
|
|
83
|
-
:param pulumi.Input[
|
|
84
|
-
|
|
228
|
+
:param pulumi.Input[Sequence[pulumi.Input[str]]] bound_issuers: `([]string: <optional>)` - The value against which to match
|
|
229
|
+
the iss claim in a JWT.
|
|
230
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] claim_mappings: Mappings of claims (key) that will be copied to a metadata field (value).
|
|
231
|
+
:param pulumi.Input[str] clock_skew_leeway: `(string: <optional>)` - Duration of leeway when validating
|
|
232
|
+
all claims in the form of a time duration such as "5m" or "1h".
|
|
85
233
|
:param pulumi.Input[Sequence[pulumi.Input[str]]] discovery_ca_pems: `([]string: <optional>)` - PEM encoded CA certs for use
|
|
86
234
|
by the TLS client used to talk with the OIDC Discovery URL.
|
|
87
|
-
:param pulumi.Input[
|
|
88
|
-
|
|
235
|
+
:param pulumi.Input[str] expiration_leeway: `(string: <optional>)` - Duration of leeway when validating
|
|
236
|
+
expiration of a JWT in the form of a time duration such as "5m" or "1h".
|
|
237
|
+
:param pulumi.Input[str] jwks_ca_cert: `(string: <optional>)` - PEM encoded CA cert for use by the
|
|
238
|
+
TLS client used to talk with the JWKS server.
|
|
239
|
+
:param pulumi.Input[str] jwks_url: `(string: <optional>)` - JSON Web Key Sets url for authenticating
|
|
240
|
+
signatures.
|
|
241
|
+
:param pulumi.Input[Sequence[pulumi.Input[str]]] jwt_validation_pub_keys: `([]string: <optional>)` - List of PEM-encoded
|
|
242
|
+
public keys to use to authenticate signatures locally.
|
|
243
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] list_claim_mappings: Mappings of list claims (key) that will be copied to a metadata field (value).
|
|
244
|
+
:param pulumi.Input[str] not_before_leeway: `(string: <optional>)` - Duration of leeway when validating
|
|
245
|
+
not before values of a token in the form of a time duration such as "5m" or "1h".
|
|
246
|
+
:param pulumi.Input[str] oidc_client_id: `(string: <optional>)` - The OAuth Client ID configured
|
|
247
|
+
with the OIDC provider.
|
|
248
|
+
:param pulumi.Input[str] oidc_client_secret: `(string: <optional>)` - The OAuth Client Secret
|
|
249
|
+
configured with the OIDC provider.
|
|
89
250
|
:param pulumi.Input[bool] oidc_disable_userinfo: `(bool: false)` - When set to `true`, Nomad will
|
|
90
251
|
not make a request to the identity provider to get OIDC `UserInfo`.
|
|
91
252
|
You may wish to set this if your identity provider doesn't send any
|
|
92
253
|
additional claims from the `UserInfo` endpoint.
|
|
254
|
+
:param pulumi.Input[str] oidc_discovery_url: `(string: <optional>)` - The OIDC Discovery URL,
|
|
255
|
+
without any .well-known component (base path).
|
|
93
256
|
:param pulumi.Input[Sequence[pulumi.Input[str]]] oidc_scopes: `([]string: <optional>)` - List of OIDC scopes.
|
|
94
257
|
:param pulumi.Input[Sequence[pulumi.Input[str]]] signing_algs: `([]string: <optional>)` - A list of supported signing
|
|
95
258
|
algorithms.
|
|
96
259
|
"""
|
|
97
|
-
|
|
98
|
-
|
|
99
|
-
pulumi.set(__self__, "oidc_client_secret", oidc_client_secret)
|
|
100
|
-
pulumi.set(__self__, "oidc_discovery_url", oidc_discovery_url)
|
|
260
|
+
if allowed_redirect_uris is not None:
|
|
261
|
+
pulumi.set(__self__, "allowed_redirect_uris", allowed_redirect_uris)
|
|
101
262
|
if bound_audiences is not None:
|
|
102
263
|
pulumi.set(__self__, "bound_audiences", bound_audiences)
|
|
264
|
+
if bound_issuers is not None:
|
|
265
|
+
pulumi.set(__self__, "bound_issuers", bound_issuers)
|
|
103
266
|
if claim_mappings is not None:
|
|
104
267
|
pulumi.set(__self__, "claim_mappings", claim_mappings)
|
|
268
|
+
if clock_skew_leeway is not None:
|
|
269
|
+
pulumi.set(__self__, "clock_skew_leeway", clock_skew_leeway)
|
|
105
270
|
if discovery_ca_pems is not None:
|
|
106
271
|
pulumi.set(__self__, "discovery_ca_pems", discovery_ca_pems)
|
|
272
|
+
if expiration_leeway is not None:
|
|
273
|
+
pulumi.set(__self__, "expiration_leeway", expiration_leeway)
|
|
274
|
+
if jwks_ca_cert is not None:
|
|
275
|
+
pulumi.set(__self__, "jwks_ca_cert", jwks_ca_cert)
|
|
276
|
+
if jwks_url is not None:
|
|
277
|
+
pulumi.set(__self__, "jwks_url", jwks_url)
|
|
278
|
+
if jwt_validation_pub_keys is not None:
|
|
279
|
+
pulumi.set(__self__, "jwt_validation_pub_keys", jwt_validation_pub_keys)
|
|
107
280
|
if list_claim_mappings is not None:
|
|
108
281
|
pulumi.set(__self__, "list_claim_mappings", list_claim_mappings)
|
|
282
|
+
if not_before_leeway is not None:
|
|
283
|
+
pulumi.set(__self__, "not_before_leeway", not_before_leeway)
|
|
284
|
+
if oidc_client_id is not None:
|
|
285
|
+
pulumi.set(__self__, "oidc_client_id", oidc_client_id)
|
|
286
|
+
if oidc_client_secret is not None:
|
|
287
|
+
pulumi.set(__self__, "oidc_client_secret", oidc_client_secret)
|
|
109
288
|
if oidc_disable_userinfo is not None:
|
|
110
289
|
pulumi.set(__self__, "oidc_disable_userinfo", oidc_disable_userinfo)
|
|
290
|
+
if oidc_discovery_url is not None:
|
|
291
|
+
pulumi.set(__self__, "oidc_discovery_url", oidc_discovery_url)
|
|
111
292
|
if oidc_scopes is not None:
|
|
112
293
|
pulumi.set(__self__, "oidc_scopes", oidc_scopes)
|
|
113
294
|
if signing_algs is not None:
|
|
@@ -115,7 +296,7 @@ class AclAuthMethodConfigArgs:
|
|
|
115
296
|
|
|
116
297
|
@property
|
|
117
298
|
@pulumi.getter(name="allowedRedirectUris")
|
|
118
|
-
def allowed_redirect_uris(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
|
|
299
|
+
def allowed_redirect_uris(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
119
300
|
"""
|
|
120
301
|
`([]string: <optional>)` - A list of allowed values
|
|
121
302
|
that can be used for the redirect URI.
|
|
@@ -123,48 +304,9 @@ class AclAuthMethodConfigArgs:
|
|
|
123
304
|
return pulumi.get(self, "allowed_redirect_uris")
|
|
124
305
|
|
|
125
306
|
@allowed_redirect_uris.setter
|
|
126
|
-
def allowed_redirect_uris(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
|
|
307
|
+
def allowed_redirect_uris(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
127
308
|
pulumi.set(self, "allowed_redirect_uris", value)
|
|
128
309
|
|
|
129
|
-
@property
|
|
130
|
-
@pulumi.getter(name="oidcClientId")
|
|
131
|
-
def oidc_client_id(self) -> pulumi.Input[str]:
|
|
132
|
-
"""
|
|
133
|
-
`(string: <required>)` - The OAuth Client ID configured
|
|
134
|
-
with the OIDC provider.
|
|
135
|
-
"""
|
|
136
|
-
return pulumi.get(self, "oidc_client_id")
|
|
137
|
-
|
|
138
|
-
@oidc_client_id.setter
|
|
139
|
-
def oidc_client_id(self, value: pulumi.Input[str]):
|
|
140
|
-
pulumi.set(self, "oidc_client_id", value)
|
|
141
|
-
|
|
142
|
-
@property
|
|
143
|
-
@pulumi.getter(name="oidcClientSecret")
|
|
144
|
-
def oidc_client_secret(self) -> pulumi.Input[str]:
|
|
145
|
-
"""
|
|
146
|
-
`(string: <required>)` - The OAuth Client Secret
|
|
147
|
-
configured with the OIDC provider.
|
|
148
|
-
"""
|
|
149
|
-
return pulumi.get(self, "oidc_client_secret")
|
|
150
|
-
|
|
151
|
-
@oidc_client_secret.setter
|
|
152
|
-
def oidc_client_secret(self, value: pulumi.Input[str]):
|
|
153
|
-
pulumi.set(self, "oidc_client_secret", value)
|
|
154
|
-
|
|
155
|
-
@property
|
|
156
|
-
@pulumi.getter(name="oidcDiscoveryUrl")
|
|
157
|
-
def oidc_discovery_url(self) -> pulumi.Input[str]:
|
|
158
|
-
"""
|
|
159
|
-
`(string: <required>)` - The OIDC Discovery URL,
|
|
160
|
-
without any .well-known component (base path).
|
|
161
|
-
"""
|
|
162
|
-
return pulumi.get(self, "oidc_discovery_url")
|
|
163
|
-
|
|
164
|
-
@oidc_discovery_url.setter
|
|
165
|
-
def oidc_discovery_url(self, value: pulumi.Input[str]):
|
|
166
|
-
pulumi.set(self, "oidc_discovery_url", value)
|
|
167
|
-
|
|
168
310
|
@property
|
|
169
311
|
@pulumi.getter(name="boundAudiences")
|
|
170
312
|
def bound_audiences(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
@@ -178,12 +320,24 @@ class AclAuthMethodConfigArgs:
|
|
|
178
320
|
def bound_audiences(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
179
321
|
pulumi.set(self, "bound_audiences", value)
|
|
180
322
|
|
|
323
|
+
@property
|
|
324
|
+
@pulumi.getter(name="boundIssuers")
|
|
325
|
+
def bound_issuers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
326
|
+
"""
|
|
327
|
+
`([]string: <optional>)` - The value against which to match
|
|
328
|
+
the iss claim in a JWT.
|
|
329
|
+
"""
|
|
330
|
+
return pulumi.get(self, "bound_issuers")
|
|
331
|
+
|
|
332
|
+
@bound_issuers.setter
|
|
333
|
+
def bound_issuers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
334
|
+
pulumi.set(self, "bound_issuers", value)
|
|
335
|
+
|
|
181
336
|
@property
|
|
182
337
|
@pulumi.getter(name="claimMappings")
|
|
183
338
|
def claim_mappings(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
184
339
|
"""
|
|
185
|
-
|
|
186
|
-
that will be copied to a metadata field (value).
|
|
340
|
+
Mappings of claims (key) that will be copied to a metadata field (value).
|
|
187
341
|
"""
|
|
188
342
|
return pulumi.get(self, "claim_mappings")
|
|
189
343
|
|
|
@@ -191,6 +345,19 @@ class AclAuthMethodConfigArgs:
|
|
|
191
345
|
def claim_mappings(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
192
346
|
pulumi.set(self, "claim_mappings", value)
|
|
193
347
|
|
|
348
|
+
@property
|
|
349
|
+
@pulumi.getter(name="clockSkewLeeway")
|
|
350
|
+
def clock_skew_leeway(self) -> Optional[pulumi.Input[str]]:
|
|
351
|
+
"""
|
|
352
|
+
`(string: <optional>)` - Duration of leeway when validating
|
|
353
|
+
all claims in the form of a time duration such as "5m" or "1h".
|
|
354
|
+
"""
|
|
355
|
+
return pulumi.get(self, "clock_skew_leeway")
|
|
356
|
+
|
|
357
|
+
@clock_skew_leeway.setter
|
|
358
|
+
def clock_skew_leeway(self, value: Optional[pulumi.Input[str]]):
|
|
359
|
+
pulumi.set(self, "clock_skew_leeway", value)
|
|
360
|
+
|
|
194
361
|
@property
|
|
195
362
|
@pulumi.getter(name="discoveryCaPems")
|
|
196
363
|
def discovery_ca_pems(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
@@ -204,12 +371,63 @@ class AclAuthMethodConfigArgs:
|
|
|
204
371
|
def discovery_ca_pems(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
205
372
|
pulumi.set(self, "discovery_ca_pems", value)
|
|
206
373
|
|
|
374
|
+
@property
|
|
375
|
+
@pulumi.getter(name="expirationLeeway")
|
|
376
|
+
def expiration_leeway(self) -> Optional[pulumi.Input[str]]:
|
|
377
|
+
"""
|
|
378
|
+
`(string: <optional>)` - Duration of leeway when validating
|
|
379
|
+
expiration of a JWT in the form of a time duration such as "5m" or "1h".
|
|
380
|
+
"""
|
|
381
|
+
return pulumi.get(self, "expiration_leeway")
|
|
382
|
+
|
|
383
|
+
@expiration_leeway.setter
|
|
384
|
+
def expiration_leeway(self, value: Optional[pulumi.Input[str]]):
|
|
385
|
+
pulumi.set(self, "expiration_leeway", value)
|
|
386
|
+
|
|
387
|
+
@property
|
|
388
|
+
@pulumi.getter(name="jwksCaCert")
|
|
389
|
+
def jwks_ca_cert(self) -> Optional[pulumi.Input[str]]:
|
|
390
|
+
"""
|
|
391
|
+
`(string: <optional>)` - PEM encoded CA cert for use by the
|
|
392
|
+
TLS client used to talk with the JWKS server.
|
|
393
|
+
"""
|
|
394
|
+
return pulumi.get(self, "jwks_ca_cert")
|
|
395
|
+
|
|
396
|
+
@jwks_ca_cert.setter
|
|
397
|
+
def jwks_ca_cert(self, value: Optional[pulumi.Input[str]]):
|
|
398
|
+
pulumi.set(self, "jwks_ca_cert", value)
|
|
399
|
+
|
|
400
|
+
@property
|
|
401
|
+
@pulumi.getter(name="jwksUrl")
|
|
402
|
+
def jwks_url(self) -> Optional[pulumi.Input[str]]:
|
|
403
|
+
"""
|
|
404
|
+
`(string: <optional>)` - JSON Web Key Sets url for authenticating
|
|
405
|
+
signatures.
|
|
406
|
+
"""
|
|
407
|
+
return pulumi.get(self, "jwks_url")
|
|
408
|
+
|
|
409
|
+
@jwks_url.setter
|
|
410
|
+
def jwks_url(self, value: Optional[pulumi.Input[str]]):
|
|
411
|
+
pulumi.set(self, "jwks_url", value)
|
|
412
|
+
|
|
413
|
+
@property
|
|
414
|
+
@pulumi.getter(name="jwtValidationPubKeys")
|
|
415
|
+
def jwt_validation_pub_keys(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
416
|
+
"""
|
|
417
|
+
`([]string: <optional>)` - List of PEM-encoded
|
|
418
|
+
public keys to use to authenticate signatures locally.
|
|
419
|
+
"""
|
|
420
|
+
return pulumi.get(self, "jwt_validation_pub_keys")
|
|
421
|
+
|
|
422
|
+
@jwt_validation_pub_keys.setter
|
|
423
|
+
def jwt_validation_pub_keys(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
424
|
+
pulumi.set(self, "jwt_validation_pub_keys", value)
|
|
425
|
+
|
|
207
426
|
@property
|
|
208
427
|
@pulumi.getter(name="listClaimMappings")
|
|
209
428
|
def list_claim_mappings(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
210
429
|
"""
|
|
211
|
-
|
|
212
|
-
claims (key) that will be copied to a metadata field (value).
|
|
430
|
+
Mappings of list claims (key) that will be copied to a metadata field (value).
|
|
213
431
|
"""
|
|
214
432
|
return pulumi.get(self, "list_claim_mappings")
|
|
215
433
|
|
|
@@ -217,6 +435,45 @@ class AclAuthMethodConfigArgs:
|
|
|
217
435
|
def list_claim_mappings(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
218
436
|
pulumi.set(self, "list_claim_mappings", value)
|
|
219
437
|
|
|
438
|
+
@property
|
|
439
|
+
@pulumi.getter(name="notBeforeLeeway")
|
|
440
|
+
def not_before_leeway(self) -> Optional[pulumi.Input[str]]:
|
|
441
|
+
"""
|
|
442
|
+
`(string: <optional>)` - Duration of leeway when validating
|
|
443
|
+
not before values of a token in the form of a time duration such as "5m" or "1h".
|
|
444
|
+
"""
|
|
445
|
+
return pulumi.get(self, "not_before_leeway")
|
|
446
|
+
|
|
447
|
+
@not_before_leeway.setter
|
|
448
|
+
def not_before_leeway(self, value: Optional[pulumi.Input[str]]):
|
|
449
|
+
pulumi.set(self, "not_before_leeway", value)
|
|
450
|
+
|
|
451
|
+
@property
|
|
452
|
+
@pulumi.getter(name="oidcClientId")
|
|
453
|
+
def oidc_client_id(self) -> Optional[pulumi.Input[str]]:
|
|
454
|
+
"""
|
|
455
|
+
`(string: <optional>)` - The OAuth Client ID configured
|
|
456
|
+
with the OIDC provider.
|
|
457
|
+
"""
|
|
458
|
+
return pulumi.get(self, "oidc_client_id")
|
|
459
|
+
|
|
460
|
+
@oidc_client_id.setter
|
|
461
|
+
def oidc_client_id(self, value: Optional[pulumi.Input[str]]):
|
|
462
|
+
pulumi.set(self, "oidc_client_id", value)
|
|
463
|
+
|
|
464
|
+
@property
|
|
465
|
+
@pulumi.getter(name="oidcClientSecret")
|
|
466
|
+
def oidc_client_secret(self) -> Optional[pulumi.Input[str]]:
|
|
467
|
+
"""
|
|
468
|
+
`(string: <optional>)` - The OAuth Client Secret
|
|
469
|
+
configured with the OIDC provider.
|
|
470
|
+
"""
|
|
471
|
+
return pulumi.get(self, "oidc_client_secret")
|
|
472
|
+
|
|
473
|
+
@oidc_client_secret.setter
|
|
474
|
+
def oidc_client_secret(self, value: Optional[pulumi.Input[str]]):
|
|
475
|
+
pulumi.set(self, "oidc_client_secret", value)
|
|
476
|
+
|
|
220
477
|
@property
|
|
221
478
|
@pulumi.getter(name="oidcDisableUserinfo")
|
|
222
479
|
def oidc_disable_userinfo(self) -> Optional[pulumi.Input[bool]]:
|
|
@@ -232,6 +489,19 @@ class AclAuthMethodConfigArgs:
|
|
|
232
489
|
def oidc_disable_userinfo(self, value: Optional[pulumi.Input[bool]]):
|
|
233
490
|
pulumi.set(self, "oidc_disable_userinfo", value)
|
|
234
491
|
|
|
492
|
+
@property
|
|
493
|
+
@pulumi.getter(name="oidcDiscoveryUrl")
|
|
494
|
+
def oidc_discovery_url(self) -> Optional[pulumi.Input[str]]:
|
|
495
|
+
"""
|
|
496
|
+
`(string: <optional>)` - The OIDC Discovery URL,
|
|
497
|
+
without any .well-known component (base path).
|
|
498
|
+
"""
|
|
499
|
+
return pulumi.get(self, "oidc_discovery_url")
|
|
500
|
+
|
|
501
|
+
@oidc_discovery_url.setter
|
|
502
|
+
def oidc_discovery_url(self, value: Optional[pulumi.Input[str]]):
|
|
503
|
+
pulumi.set(self, "oidc_discovery_url", value)
|
|
504
|
+
|
|
235
505
|
@property
|
|
236
506
|
@pulumi.getter(name="oidcScopes")
|
|
237
507
|
def oidc_scopes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
@@ -258,6 +528,27 @@ class AclAuthMethodConfigArgs:
|
|
|
258
528
|
pulumi.set(self, "signing_algs", value)
|
|
259
529
|
|
|
260
530
|
|
|
531
|
+
if not MYPY:
|
|
532
|
+
class AclPolicyJobAclArgsDict(TypedDict):
|
|
533
|
+
job_id: pulumi.Input[str]
|
|
534
|
+
"""
|
|
535
|
+
Job
|
|
536
|
+
"""
|
|
537
|
+
group: NotRequired[pulumi.Input[str]]
|
|
538
|
+
"""
|
|
539
|
+
Group
|
|
540
|
+
"""
|
|
541
|
+
namespace: NotRequired[pulumi.Input[str]]
|
|
542
|
+
"""
|
|
543
|
+
Namespace
|
|
544
|
+
"""
|
|
545
|
+
task: NotRequired[pulumi.Input[str]]
|
|
546
|
+
"""
|
|
547
|
+
Task
|
|
548
|
+
"""
|
|
549
|
+
elif False:
|
|
550
|
+
AclPolicyJobAclArgsDict: TypeAlias = Mapping[str, Any]
|
|
551
|
+
|
|
261
552
|
@pulumi.input_type
|
|
262
553
|
class AclPolicyJobAclArgs:
|
|
263
554
|
def __init__(__self__, *,
|
|
@@ -266,15 +557,10 @@ class AclPolicyJobAclArgs:
|
|
|
266
557
|
namespace: Optional[pulumi.Input[str]] = None,
|
|
267
558
|
task: Optional[pulumi.Input[str]] = None):
|
|
268
559
|
"""
|
|
269
|
-
:param pulumi.Input[str] job_id:
|
|
270
|
-
|
|
271
|
-
:param pulumi.Input[str]
|
|
272
|
-
|
|
273
|
-
:param pulumi.Input[str] namespace: `(string: "default")` - The namespace to attach the policy.
|
|
274
|
-
Required if `job_id` is set.
|
|
275
|
-
:param pulumi.Input[str] task: `(string: <optional>` - The task to attach the policy.
|
|
276
|
-
|
|
277
|
-
[nomad_docs_wi]: https://www.nomadproject.io/docs/concepts/workload-identity#workload-associated-acl-policies
|
|
560
|
+
:param pulumi.Input[str] job_id: Job
|
|
561
|
+
:param pulumi.Input[str] group: Group
|
|
562
|
+
:param pulumi.Input[str] namespace: Namespace
|
|
563
|
+
:param pulumi.Input[str] task: Task
|
|
278
564
|
"""
|
|
279
565
|
pulumi.set(__self__, "job_id", job_id)
|
|
280
566
|
if group is not None:
|
|
@@ -288,8 +574,7 @@ class AclPolicyJobAclArgs:
|
|
|
288
574
|
@pulumi.getter(name="jobId")
|
|
289
575
|
def job_id(self) -> pulumi.Input[str]:
|
|
290
576
|
"""
|
|
291
|
-
|
|
292
|
-
`group` is set.
|
|
577
|
+
Job
|
|
293
578
|
"""
|
|
294
579
|
return pulumi.get(self, "job_id")
|
|
295
580
|
|
|
@@ -301,8 +586,7 @@ class AclPolicyJobAclArgs:
|
|
|
301
586
|
@pulumi.getter
|
|
302
587
|
def group(self) -> Optional[pulumi.Input[str]]:
|
|
303
588
|
"""
|
|
304
|
-
|
|
305
|
-
`task` is set.
|
|
589
|
+
Group
|
|
306
590
|
"""
|
|
307
591
|
return pulumi.get(self, "group")
|
|
308
592
|
|
|
@@ -314,8 +598,7 @@ class AclPolicyJobAclArgs:
|
|
|
314
598
|
@pulumi.getter
|
|
315
599
|
def namespace(self) -> Optional[pulumi.Input[str]]:
|
|
316
600
|
"""
|
|
317
|
-
|
|
318
|
-
Required if `job_id` is set.
|
|
601
|
+
Namespace
|
|
319
602
|
"""
|
|
320
603
|
return pulumi.get(self, "namespace")
|
|
321
604
|
|
|
@@ -327,9 +610,7 @@ class AclPolicyJobAclArgs:
|
|
|
327
610
|
@pulumi.getter
|
|
328
611
|
def task(self) -> Optional[pulumi.Input[str]]:
|
|
329
612
|
"""
|
|
330
|
-
|
|
331
|
-
|
|
332
|
-
[nomad_docs_wi]: https://www.nomadproject.io/docs/concepts/workload-identity#workload-associated-acl-policies
|
|
613
|
+
Task
|
|
333
614
|
"""
|
|
334
615
|
return pulumi.get(self, "task")
|
|
335
616
|
|
|
@@ -338,6 +619,15 @@ class AclPolicyJobAclArgs:
|
|
|
338
619
|
pulumi.set(self, "task", value)
|
|
339
620
|
|
|
340
621
|
|
|
622
|
+
if not MYPY:
|
|
623
|
+
class AclRolePolicyArgsDict(TypedDict):
|
|
624
|
+
name: pulumi.Input[str]
|
|
625
|
+
"""
|
|
626
|
+
`(string: <required>)` - A human-friendly name for this ACL Role.
|
|
627
|
+
"""
|
|
628
|
+
elif False:
|
|
629
|
+
AclRolePolicyArgsDict: TypeAlias = Mapping[str, Any]
|
|
630
|
+
|
|
341
631
|
@pulumi.input_type
|
|
342
632
|
class AclRolePolicyArgs:
|
|
343
633
|
def __init__(__self__, *,
|
|
@@ -360,6 +650,19 @@ class AclRolePolicyArgs:
|
|
|
360
650
|
pulumi.set(self, "name", value)
|
|
361
651
|
|
|
362
652
|
|
|
653
|
+
if not MYPY:
|
|
654
|
+
class AclTokenRoleArgsDict(TypedDict):
|
|
655
|
+
id: pulumi.Input[str]
|
|
656
|
+
"""
|
|
657
|
+
The ID of the ACL role to link.
|
|
658
|
+
"""
|
|
659
|
+
name: NotRequired[pulumi.Input[str]]
|
|
660
|
+
"""
|
|
661
|
+
`(string: "")` - A human-friendly name for this token.
|
|
662
|
+
"""
|
|
663
|
+
elif False:
|
|
664
|
+
AclTokenRoleArgsDict: TypeAlias = Mapping[str, Any]
|
|
665
|
+
|
|
363
666
|
@pulumi.input_type
|
|
364
667
|
class AclTokenRoleArgs:
|
|
365
668
|
def __init__(__self__, *,
|
|
@@ -398,6 +701,26 @@ class AclTokenRoleArgs:
|
|
|
398
701
|
pulumi.set(self, "name", value)
|
|
399
702
|
|
|
400
703
|
|
|
704
|
+
if not MYPY:
|
|
705
|
+
class CsiVolumeCapabilityArgsDict(TypedDict):
|
|
706
|
+
access_mode: pulumi.Input[str]
|
|
707
|
+
"""
|
|
708
|
+
`(string: <required>)` - Defines whether a volume should be available concurrently. Possible values are:
|
|
709
|
+
- `single-node-reader-only`
|
|
710
|
+
- `single-node-writer`
|
|
711
|
+
- `multi-node-reader-only`
|
|
712
|
+
- `multi-node-single-writer`
|
|
713
|
+
- `multi-node-multi-writer`
|
|
714
|
+
"""
|
|
715
|
+
attachment_mode: pulumi.Input[str]
|
|
716
|
+
"""
|
|
717
|
+
`(string: <required>)` - The storage API that will be used by the volume. Possible values are:
|
|
718
|
+
- `block-device`
|
|
719
|
+
- `file-system`
|
|
720
|
+
"""
|
|
721
|
+
elif False:
|
|
722
|
+
CsiVolumeCapabilityArgsDict: TypeAlias = Mapping[str, Any]
|
|
723
|
+
|
|
401
724
|
@pulumi.input_type
|
|
402
725
|
class CsiVolumeCapabilityArgs:
|
|
403
726
|
def __init__(__self__, *,
|
|
@@ -449,6 +772,19 @@ class CsiVolumeCapabilityArgs:
|
|
|
449
772
|
pulumi.set(self, "attachment_mode", value)
|
|
450
773
|
|
|
451
774
|
|
|
775
|
+
if not MYPY:
|
|
776
|
+
class CsiVolumeMountOptionsArgsDict(TypedDict):
|
|
777
|
+
fs_type: NotRequired[pulumi.Input[str]]
|
|
778
|
+
"""
|
|
779
|
+
`(string: optional)` - The file system type.
|
|
780
|
+
"""
|
|
781
|
+
mount_flags: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
782
|
+
"""
|
|
783
|
+
`[]string: optional` - The flags passed to `mount`.
|
|
784
|
+
"""
|
|
785
|
+
elif False:
|
|
786
|
+
CsiVolumeMountOptionsArgsDict: TypeAlias = Mapping[str, Any]
|
|
787
|
+
|
|
452
788
|
@pulumi.input_type
|
|
453
789
|
class CsiVolumeMountOptionsArgs:
|
|
454
790
|
def __init__(__self__, *,
|
|
@@ -488,6 +824,26 @@ class CsiVolumeMountOptionsArgs:
|
|
|
488
824
|
pulumi.set(self, "mount_flags", value)
|
|
489
825
|
|
|
490
826
|
|
|
827
|
+
if not MYPY:
|
|
828
|
+
class CsiVolumeRegistrationCapabilityArgsDict(TypedDict):
|
|
829
|
+
access_mode: pulumi.Input[str]
|
|
830
|
+
"""
|
|
831
|
+
`(string: <required>)` - Defines whether a volume should be available concurrently. Possible values are:
|
|
832
|
+
- `single-node-reader-only`
|
|
833
|
+
- `single-node-writer`
|
|
834
|
+
- `multi-node-reader-only`
|
|
835
|
+
- `multi-node-single-writer`
|
|
836
|
+
- `multi-node-multi-writer`
|
|
837
|
+
"""
|
|
838
|
+
attachment_mode: pulumi.Input[str]
|
|
839
|
+
"""
|
|
840
|
+
`(string: <required>)` - The storage API that will be used by the volume. Possible values are:
|
|
841
|
+
- `block-device`
|
|
842
|
+
- `file-system`
|
|
843
|
+
"""
|
|
844
|
+
elif False:
|
|
845
|
+
CsiVolumeRegistrationCapabilityArgsDict: TypeAlias = Mapping[str, Any]
|
|
846
|
+
|
|
491
847
|
@pulumi.input_type
|
|
492
848
|
class CsiVolumeRegistrationCapabilityArgs:
|
|
493
849
|
def __init__(__self__, *,
|
|
@@ -539,6 +895,19 @@ class CsiVolumeRegistrationCapabilityArgs:
|
|
|
539
895
|
pulumi.set(self, "attachment_mode", value)
|
|
540
896
|
|
|
541
897
|
|
|
898
|
+
if not MYPY:
|
|
899
|
+
class CsiVolumeRegistrationMountOptionsArgsDict(TypedDict):
|
|
900
|
+
fs_type: NotRequired[pulumi.Input[str]]
|
|
901
|
+
"""
|
|
902
|
+
`(string: <optional>)` - The file system type.
|
|
903
|
+
"""
|
|
904
|
+
mount_flags: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
905
|
+
"""
|
|
906
|
+
`([]string: <optional>)` - The flags passed to `mount`.
|
|
907
|
+
"""
|
|
908
|
+
elif False:
|
|
909
|
+
CsiVolumeRegistrationMountOptionsArgsDict: TypeAlias = Mapping[str, Any]
|
|
910
|
+
|
|
542
911
|
@pulumi.input_type
|
|
543
912
|
class CsiVolumeRegistrationMountOptionsArgs:
|
|
544
913
|
def __init__(__self__, *,
|
|
@@ -578,6 +947,18 @@ class CsiVolumeRegistrationMountOptionsArgs:
|
|
|
578
947
|
pulumi.set(self, "mount_flags", value)
|
|
579
948
|
|
|
580
949
|
|
|
950
|
+
if not MYPY:
|
|
951
|
+
class CsiVolumeRegistrationTopologyArgsDict(TypedDict):
|
|
952
|
+
segments: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
953
|
+
"""
|
|
954
|
+
`(map[string]string)` - Define the attributes for the topology request.
|
|
955
|
+
|
|
956
|
+
In addition to the above arguments, the following attributes are exported and
|
|
957
|
+
can be referenced:
|
|
958
|
+
"""
|
|
959
|
+
elif False:
|
|
960
|
+
CsiVolumeRegistrationTopologyArgsDict: TypeAlias = Mapping[str, Any]
|
|
961
|
+
|
|
581
962
|
@pulumi.input_type
|
|
582
963
|
class CsiVolumeRegistrationTopologyArgs:
|
|
583
964
|
def __init__(__self__, *,
|
|
@@ -607,6 +988,15 @@ class CsiVolumeRegistrationTopologyArgs:
|
|
|
607
988
|
pulumi.set(self, "segments", value)
|
|
608
989
|
|
|
609
990
|
|
|
991
|
+
if not MYPY:
|
|
992
|
+
class CsiVolumeRegistrationTopologyRequestArgsDict(TypedDict):
|
|
993
|
+
required: NotRequired[pulumi.Input['CsiVolumeRegistrationTopologyRequestRequiredArgsDict']]
|
|
994
|
+
"""
|
|
995
|
+
`(``Topology``: <optional>)` - Required topologies indicate that the volume must be created in a location accessible from all the listed topologies.
|
|
996
|
+
"""
|
|
997
|
+
elif False:
|
|
998
|
+
CsiVolumeRegistrationTopologyRequestArgsDict: TypeAlias = Mapping[str, Any]
|
|
999
|
+
|
|
610
1000
|
@pulumi.input_type
|
|
611
1001
|
class CsiVolumeRegistrationTopologyRequestArgs:
|
|
612
1002
|
def __init__(__self__, *,
|
|
@@ -630,12 +1020,21 @@ class CsiVolumeRegistrationTopologyRequestArgs:
|
|
|
630
1020
|
pulumi.set(self, "required", value)
|
|
631
1021
|
|
|
632
1022
|
|
|
1023
|
+
if not MYPY:
|
|
1024
|
+
class CsiVolumeRegistrationTopologyRequestRequiredArgsDict(TypedDict):
|
|
1025
|
+
topologies: pulumi.Input[Sequence[pulumi.Input['CsiVolumeRegistrationTopologyRequestRequiredTopologyArgsDict']]]
|
|
1026
|
+
"""
|
|
1027
|
+
Defines the location for the volume.
|
|
1028
|
+
"""
|
|
1029
|
+
elif False:
|
|
1030
|
+
CsiVolumeRegistrationTopologyRequestRequiredArgsDict: TypeAlias = Mapping[str, Any]
|
|
1031
|
+
|
|
633
1032
|
@pulumi.input_type
|
|
634
1033
|
class CsiVolumeRegistrationTopologyRequestRequiredArgs:
|
|
635
1034
|
def __init__(__self__, *,
|
|
636
1035
|
topologies: pulumi.Input[Sequence[pulumi.Input['CsiVolumeRegistrationTopologyRequestRequiredTopologyArgs']]]):
|
|
637
1036
|
"""
|
|
638
|
-
:param pulumi.Input[Sequence[pulumi.Input['CsiVolumeRegistrationTopologyRequestRequiredTopologyArgs']]] topologies:
|
|
1037
|
+
:param pulumi.Input[Sequence[pulumi.Input['CsiVolumeRegistrationTopologyRequestRequiredTopologyArgs']]] topologies: Defines the location for the volume.
|
|
639
1038
|
"""
|
|
640
1039
|
pulumi.set(__self__, "topologies", topologies)
|
|
641
1040
|
|
|
@@ -643,7 +1042,7 @@ class CsiVolumeRegistrationTopologyRequestRequiredArgs:
|
|
|
643
1042
|
@pulumi.getter
|
|
644
1043
|
def topologies(self) -> pulumi.Input[Sequence[pulumi.Input['CsiVolumeRegistrationTopologyRequestRequiredTopologyArgs']]]:
|
|
645
1044
|
"""
|
|
646
|
-
|
|
1045
|
+
Defines the location for the volume.
|
|
647
1046
|
"""
|
|
648
1047
|
return pulumi.get(self, "topologies")
|
|
649
1048
|
|
|
@@ -652,15 +1051,21 @@ class CsiVolumeRegistrationTopologyRequestRequiredArgs:
|
|
|
652
1051
|
pulumi.set(self, "topologies", value)
|
|
653
1052
|
|
|
654
1053
|
|
|
1054
|
+
if not MYPY:
|
|
1055
|
+
class CsiVolumeRegistrationTopologyRequestRequiredTopologyArgsDict(TypedDict):
|
|
1056
|
+
segments: pulumi.Input[Mapping[str, pulumi.Input[str]]]
|
|
1057
|
+
"""
|
|
1058
|
+
Define attributes for the topology request.
|
|
1059
|
+
"""
|
|
1060
|
+
elif False:
|
|
1061
|
+
CsiVolumeRegistrationTopologyRequestRequiredTopologyArgsDict: TypeAlias = Mapping[str, Any]
|
|
1062
|
+
|
|
655
1063
|
@pulumi.input_type
|
|
656
1064
|
class CsiVolumeRegistrationTopologyRequestRequiredTopologyArgs:
|
|
657
1065
|
def __init__(__self__, *,
|
|
658
1066
|
segments: pulumi.Input[Mapping[str, pulumi.Input[str]]]):
|
|
659
1067
|
"""
|
|
660
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] segments:
|
|
661
|
-
|
|
662
|
-
In addition to the above arguments, the following attributes are exported and
|
|
663
|
-
can be referenced:
|
|
1068
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] segments: Define attributes for the topology request.
|
|
664
1069
|
"""
|
|
665
1070
|
pulumi.set(__self__, "segments", segments)
|
|
666
1071
|
|
|
@@ -668,10 +1073,7 @@ class CsiVolumeRegistrationTopologyRequestRequiredTopologyArgs:
|
|
|
668
1073
|
@pulumi.getter
|
|
669
1074
|
def segments(self) -> pulumi.Input[Mapping[str, pulumi.Input[str]]]:
|
|
670
1075
|
"""
|
|
671
|
-
|
|
672
|
-
|
|
673
|
-
In addition to the above arguments, the following attributes are exported and
|
|
674
|
-
can be referenced:
|
|
1076
|
+
Define attributes for the topology request.
|
|
675
1077
|
"""
|
|
676
1078
|
return pulumi.get(self, "segments")
|
|
677
1079
|
|
|
@@ -680,6 +1082,18 @@ class CsiVolumeRegistrationTopologyRequestRequiredTopologyArgs:
|
|
|
680
1082
|
pulumi.set(self, "segments", value)
|
|
681
1083
|
|
|
682
1084
|
|
|
1085
|
+
if not MYPY:
|
|
1086
|
+
class CsiVolumeTopologyArgsDict(TypedDict):
|
|
1087
|
+
segments: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
1088
|
+
"""
|
|
1089
|
+
`(map[string]string)` - Define the attributes for the topology request.
|
|
1090
|
+
|
|
1091
|
+
In addition to the above arguments, the following attributes are exported and
|
|
1092
|
+
can be referenced:
|
|
1093
|
+
"""
|
|
1094
|
+
elif False:
|
|
1095
|
+
CsiVolumeTopologyArgsDict: TypeAlias = Mapping[str, Any]
|
|
1096
|
+
|
|
683
1097
|
@pulumi.input_type
|
|
684
1098
|
class CsiVolumeTopologyArgs:
|
|
685
1099
|
def __init__(__self__, *,
|
|
@@ -709,6 +1123,19 @@ class CsiVolumeTopologyArgs:
|
|
|
709
1123
|
pulumi.set(self, "segments", value)
|
|
710
1124
|
|
|
711
1125
|
|
|
1126
|
+
if not MYPY:
|
|
1127
|
+
class CsiVolumeTopologyRequestArgsDict(TypedDict):
|
|
1128
|
+
preferred: NotRequired[pulumi.Input['CsiVolumeTopologyRequestPreferredArgsDict']]
|
|
1129
|
+
"""
|
|
1130
|
+
`(``Topology``: <optional>)` - Preferred topologies indicate that the volume should be created in a location accessible from some of the listed topologies.
|
|
1131
|
+
"""
|
|
1132
|
+
required: NotRequired[pulumi.Input['CsiVolumeTopologyRequestRequiredArgsDict']]
|
|
1133
|
+
"""
|
|
1134
|
+
`(``Topology``: <optional>)` - Required topologies indicate that the volume must be created in a location accessible from all the listed topologies.
|
|
1135
|
+
"""
|
|
1136
|
+
elif False:
|
|
1137
|
+
CsiVolumeTopologyRequestArgsDict: TypeAlias = Mapping[str, Any]
|
|
1138
|
+
|
|
712
1139
|
@pulumi.input_type
|
|
713
1140
|
class CsiVolumeTopologyRequestArgs:
|
|
714
1141
|
def __init__(__self__, *,
|
|
@@ -748,12 +1175,21 @@ class CsiVolumeTopologyRequestArgs:
|
|
|
748
1175
|
pulumi.set(self, "required", value)
|
|
749
1176
|
|
|
750
1177
|
|
|
1178
|
+
if not MYPY:
|
|
1179
|
+
class CsiVolumeTopologyRequestPreferredArgsDict(TypedDict):
|
|
1180
|
+
topologies: pulumi.Input[Sequence[pulumi.Input['CsiVolumeTopologyRequestPreferredTopologyArgsDict']]]
|
|
1181
|
+
"""
|
|
1182
|
+
Defines the location for the volume.
|
|
1183
|
+
"""
|
|
1184
|
+
elif False:
|
|
1185
|
+
CsiVolumeTopologyRequestPreferredArgsDict: TypeAlias = Mapping[str, Any]
|
|
1186
|
+
|
|
751
1187
|
@pulumi.input_type
|
|
752
1188
|
class CsiVolumeTopologyRequestPreferredArgs:
|
|
753
1189
|
def __init__(__self__, *,
|
|
754
1190
|
topologies: pulumi.Input[Sequence[pulumi.Input['CsiVolumeTopologyRequestPreferredTopologyArgs']]]):
|
|
755
1191
|
"""
|
|
756
|
-
:param pulumi.Input[Sequence[pulumi.Input['CsiVolumeTopologyRequestPreferredTopologyArgs']]] topologies:
|
|
1192
|
+
:param pulumi.Input[Sequence[pulumi.Input['CsiVolumeTopologyRequestPreferredTopologyArgs']]] topologies: Defines the location for the volume.
|
|
757
1193
|
"""
|
|
758
1194
|
pulumi.set(__self__, "topologies", topologies)
|
|
759
1195
|
|
|
@@ -761,7 +1197,7 @@ class CsiVolumeTopologyRequestPreferredArgs:
|
|
|
761
1197
|
@pulumi.getter
|
|
762
1198
|
def topologies(self) -> pulumi.Input[Sequence[pulumi.Input['CsiVolumeTopologyRequestPreferredTopologyArgs']]]:
|
|
763
1199
|
"""
|
|
764
|
-
|
|
1200
|
+
Defines the location for the volume.
|
|
765
1201
|
"""
|
|
766
1202
|
return pulumi.get(self, "topologies")
|
|
767
1203
|
|
|
@@ -770,15 +1206,21 @@ class CsiVolumeTopologyRequestPreferredArgs:
|
|
|
770
1206
|
pulumi.set(self, "topologies", value)
|
|
771
1207
|
|
|
772
1208
|
|
|
1209
|
+
if not MYPY:
|
|
1210
|
+
class CsiVolumeTopologyRequestPreferredTopologyArgsDict(TypedDict):
|
|
1211
|
+
segments: pulumi.Input[Mapping[str, pulumi.Input[str]]]
|
|
1212
|
+
"""
|
|
1213
|
+
Define the attributes for the topology request.
|
|
1214
|
+
"""
|
|
1215
|
+
elif False:
|
|
1216
|
+
CsiVolumeTopologyRequestPreferredTopologyArgsDict: TypeAlias = Mapping[str, Any]
|
|
1217
|
+
|
|
773
1218
|
@pulumi.input_type
|
|
774
1219
|
class CsiVolumeTopologyRequestPreferredTopologyArgs:
|
|
775
1220
|
def __init__(__self__, *,
|
|
776
1221
|
segments: pulumi.Input[Mapping[str, pulumi.Input[str]]]):
|
|
777
1222
|
"""
|
|
778
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] segments:
|
|
779
|
-
|
|
780
|
-
In addition to the above arguments, the following attributes are exported and
|
|
781
|
-
can be referenced:
|
|
1223
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] segments: Define the attributes for the topology request.
|
|
782
1224
|
"""
|
|
783
1225
|
pulumi.set(__self__, "segments", segments)
|
|
784
1226
|
|
|
@@ -786,10 +1228,7 @@ class CsiVolumeTopologyRequestPreferredTopologyArgs:
|
|
|
786
1228
|
@pulumi.getter
|
|
787
1229
|
def segments(self) -> pulumi.Input[Mapping[str, pulumi.Input[str]]]:
|
|
788
1230
|
"""
|
|
789
|
-
|
|
790
|
-
|
|
791
|
-
In addition to the above arguments, the following attributes are exported and
|
|
792
|
-
can be referenced:
|
|
1231
|
+
Define the attributes for the topology request.
|
|
793
1232
|
"""
|
|
794
1233
|
return pulumi.get(self, "segments")
|
|
795
1234
|
|
|
@@ -798,12 +1237,21 @@ class CsiVolumeTopologyRequestPreferredTopologyArgs:
|
|
|
798
1237
|
pulumi.set(self, "segments", value)
|
|
799
1238
|
|
|
800
1239
|
|
|
1240
|
+
if not MYPY:
|
|
1241
|
+
class CsiVolumeTopologyRequestRequiredArgsDict(TypedDict):
|
|
1242
|
+
topologies: pulumi.Input[Sequence[pulumi.Input['CsiVolumeTopologyRequestRequiredTopologyArgsDict']]]
|
|
1243
|
+
"""
|
|
1244
|
+
Defines the location for the volume.
|
|
1245
|
+
"""
|
|
1246
|
+
elif False:
|
|
1247
|
+
CsiVolumeTopologyRequestRequiredArgsDict: TypeAlias = Mapping[str, Any]
|
|
1248
|
+
|
|
801
1249
|
@pulumi.input_type
|
|
802
1250
|
class CsiVolumeTopologyRequestRequiredArgs:
|
|
803
1251
|
def __init__(__self__, *,
|
|
804
1252
|
topologies: pulumi.Input[Sequence[pulumi.Input['CsiVolumeTopologyRequestRequiredTopologyArgs']]]):
|
|
805
1253
|
"""
|
|
806
|
-
:param pulumi.Input[Sequence[pulumi.Input['CsiVolumeTopologyRequestRequiredTopologyArgs']]] topologies:
|
|
1254
|
+
:param pulumi.Input[Sequence[pulumi.Input['CsiVolumeTopologyRequestRequiredTopologyArgs']]] topologies: Defines the location for the volume.
|
|
807
1255
|
"""
|
|
808
1256
|
pulumi.set(__self__, "topologies", topologies)
|
|
809
1257
|
|
|
@@ -811,7 +1259,7 @@ class CsiVolumeTopologyRequestRequiredArgs:
|
|
|
811
1259
|
@pulumi.getter
|
|
812
1260
|
def topologies(self) -> pulumi.Input[Sequence[pulumi.Input['CsiVolumeTopologyRequestRequiredTopologyArgs']]]:
|
|
813
1261
|
"""
|
|
814
|
-
|
|
1262
|
+
Defines the location for the volume.
|
|
815
1263
|
"""
|
|
816
1264
|
return pulumi.get(self, "topologies")
|
|
817
1265
|
|
|
@@ -820,15 +1268,21 @@ class CsiVolumeTopologyRequestRequiredArgs:
|
|
|
820
1268
|
pulumi.set(self, "topologies", value)
|
|
821
1269
|
|
|
822
1270
|
|
|
1271
|
+
if not MYPY:
|
|
1272
|
+
class CsiVolumeTopologyRequestRequiredTopologyArgsDict(TypedDict):
|
|
1273
|
+
segments: pulumi.Input[Mapping[str, pulumi.Input[str]]]
|
|
1274
|
+
"""
|
|
1275
|
+
Define the attributes for the topology request.
|
|
1276
|
+
"""
|
|
1277
|
+
elif False:
|
|
1278
|
+
CsiVolumeTopologyRequestRequiredTopologyArgsDict: TypeAlias = Mapping[str, Any]
|
|
1279
|
+
|
|
823
1280
|
@pulumi.input_type
|
|
824
1281
|
class CsiVolumeTopologyRequestRequiredTopologyArgs:
|
|
825
1282
|
def __init__(__self__, *,
|
|
826
1283
|
segments: pulumi.Input[Mapping[str, pulumi.Input[str]]]):
|
|
827
1284
|
"""
|
|
828
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] segments:
|
|
829
|
-
|
|
830
|
-
In addition to the above arguments, the following attributes are exported and
|
|
831
|
-
can be referenced:
|
|
1285
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] segments: Define the attributes for the topology request.
|
|
832
1286
|
"""
|
|
833
1287
|
pulumi.set(__self__, "segments", segments)
|
|
834
1288
|
|
|
@@ -836,10 +1290,7 @@ class CsiVolumeTopologyRequestRequiredTopologyArgs:
|
|
|
836
1290
|
@pulumi.getter
|
|
837
1291
|
def segments(self) -> pulumi.Input[Mapping[str, pulumi.Input[str]]]:
|
|
838
1292
|
"""
|
|
839
|
-
|
|
840
|
-
|
|
841
|
-
In addition to the above arguments, the following attributes are exported and
|
|
842
|
-
can be referenced:
|
|
1293
|
+
Define the attributes for the topology request.
|
|
843
1294
|
"""
|
|
844
1295
|
return pulumi.get(self, "segments")
|
|
845
1296
|
|
|
@@ -848,6 +1299,26 @@ class CsiVolumeTopologyRequestRequiredTopologyArgs:
|
|
|
848
1299
|
pulumi.set(self, "segments", value)
|
|
849
1300
|
|
|
850
1301
|
|
|
1302
|
+
if not MYPY:
|
|
1303
|
+
class ExternalVolumeCapabilityArgsDict(TypedDict):
|
|
1304
|
+
access_mode: pulumi.Input[str]
|
|
1305
|
+
"""
|
|
1306
|
+
`(string: <required>)` - Defines whether a volume should be available concurrently. Possible values are:
|
|
1307
|
+
- `single-node-reader-only`
|
|
1308
|
+
- `single-node-writer`
|
|
1309
|
+
- `multi-node-reader-only`
|
|
1310
|
+
- `multi-node-single-writer`
|
|
1311
|
+
- `multi-node-multi-writer`
|
|
1312
|
+
"""
|
|
1313
|
+
attachment_mode: pulumi.Input[str]
|
|
1314
|
+
"""
|
|
1315
|
+
`(string: <required>)` - The storage API that will be used by the volume. Possible values are:
|
|
1316
|
+
- `block-device`
|
|
1317
|
+
- `file-system`
|
|
1318
|
+
"""
|
|
1319
|
+
elif False:
|
|
1320
|
+
ExternalVolumeCapabilityArgsDict: TypeAlias = Mapping[str, Any]
|
|
1321
|
+
|
|
851
1322
|
@pulumi.input_type
|
|
852
1323
|
class ExternalVolumeCapabilityArgs:
|
|
853
1324
|
def __init__(__self__, *,
|
|
@@ -899,6 +1370,19 @@ class ExternalVolumeCapabilityArgs:
|
|
|
899
1370
|
pulumi.set(self, "attachment_mode", value)
|
|
900
1371
|
|
|
901
1372
|
|
|
1373
|
+
if not MYPY:
|
|
1374
|
+
class ExternalVolumeMountOptionsArgsDict(TypedDict):
|
|
1375
|
+
fs_type: NotRequired[pulumi.Input[str]]
|
|
1376
|
+
"""
|
|
1377
|
+
`(string: optional)` - The file system type.
|
|
1378
|
+
"""
|
|
1379
|
+
mount_flags: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
1380
|
+
"""
|
|
1381
|
+
`[]string: optional` - The flags passed to `mount`.
|
|
1382
|
+
"""
|
|
1383
|
+
elif False:
|
|
1384
|
+
ExternalVolumeMountOptionsArgsDict: TypeAlias = Mapping[str, Any]
|
|
1385
|
+
|
|
902
1386
|
@pulumi.input_type
|
|
903
1387
|
class ExternalVolumeMountOptionsArgs:
|
|
904
1388
|
def __init__(__self__, *,
|
|
@@ -938,6 +1422,18 @@ class ExternalVolumeMountOptionsArgs:
|
|
|
938
1422
|
pulumi.set(self, "mount_flags", value)
|
|
939
1423
|
|
|
940
1424
|
|
|
1425
|
+
if not MYPY:
|
|
1426
|
+
class ExternalVolumeTopologyArgsDict(TypedDict):
|
|
1427
|
+
segments: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
1428
|
+
"""
|
|
1429
|
+
`(map[string]string)` - Define the attributes for the topology request.
|
|
1430
|
+
|
|
1431
|
+
In addition to the above arguments, the following attributes are exported and
|
|
1432
|
+
can be referenced:
|
|
1433
|
+
"""
|
|
1434
|
+
elif False:
|
|
1435
|
+
ExternalVolumeTopologyArgsDict: TypeAlias = Mapping[str, Any]
|
|
1436
|
+
|
|
941
1437
|
@pulumi.input_type
|
|
942
1438
|
class ExternalVolumeTopologyArgs:
|
|
943
1439
|
def __init__(__self__, *,
|
|
@@ -967,6 +1463,19 @@ class ExternalVolumeTopologyArgs:
|
|
|
967
1463
|
pulumi.set(self, "segments", value)
|
|
968
1464
|
|
|
969
1465
|
|
|
1466
|
+
if not MYPY:
|
|
1467
|
+
class ExternalVolumeTopologyRequestArgsDict(TypedDict):
|
|
1468
|
+
preferred: NotRequired[pulumi.Input['ExternalVolumeTopologyRequestPreferredArgsDict']]
|
|
1469
|
+
"""
|
|
1470
|
+
`(``Topology``: <optional>)` - Preferred topologies indicate that the volume should be created in a location accessible from some of the listed topologies.
|
|
1471
|
+
"""
|
|
1472
|
+
required: NotRequired[pulumi.Input['ExternalVolumeTopologyRequestRequiredArgsDict']]
|
|
1473
|
+
"""
|
|
1474
|
+
`(``Topology``: <optional>)` - Required topologies indicate that the volume must be created in a location accessible from all the listed topologies.
|
|
1475
|
+
"""
|
|
1476
|
+
elif False:
|
|
1477
|
+
ExternalVolumeTopologyRequestArgsDict: TypeAlias = Mapping[str, Any]
|
|
1478
|
+
|
|
970
1479
|
@pulumi.input_type
|
|
971
1480
|
class ExternalVolumeTopologyRequestArgs:
|
|
972
1481
|
def __init__(__self__, *,
|
|
@@ -1006,12 +1515,21 @@ class ExternalVolumeTopologyRequestArgs:
|
|
|
1006
1515
|
pulumi.set(self, "required", value)
|
|
1007
1516
|
|
|
1008
1517
|
|
|
1518
|
+
if not MYPY:
|
|
1519
|
+
class ExternalVolumeTopologyRequestPreferredArgsDict(TypedDict):
|
|
1520
|
+
topologies: pulumi.Input[Sequence[pulumi.Input['ExternalVolumeTopologyRequestPreferredTopologyArgsDict']]]
|
|
1521
|
+
"""
|
|
1522
|
+
Defines the location for the volume.
|
|
1523
|
+
"""
|
|
1524
|
+
elif False:
|
|
1525
|
+
ExternalVolumeTopologyRequestPreferredArgsDict: TypeAlias = Mapping[str, Any]
|
|
1526
|
+
|
|
1009
1527
|
@pulumi.input_type
|
|
1010
1528
|
class ExternalVolumeTopologyRequestPreferredArgs:
|
|
1011
1529
|
def __init__(__self__, *,
|
|
1012
1530
|
topologies: pulumi.Input[Sequence[pulumi.Input['ExternalVolumeTopologyRequestPreferredTopologyArgs']]]):
|
|
1013
1531
|
"""
|
|
1014
|
-
:param pulumi.Input[Sequence[pulumi.Input['ExternalVolumeTopologyRequestPreferredTopologyArgs']]] topologies:
|
|
1532
|
+
:param pulumi.Input[Sequence[pulumi.Input['ExternalVolumeTopologyRequestPreferredTopologyArgs']]] topologies: Defines the location for the volume.
|
|
1015
1533
|
"""
|
|
1016
1534
|
pulumi.set(__self__, "topologies", topologies)
|
|
1017
1535
|
|
|
@@ -1019,7 +1537,7 @@ class ExternalVolumeTopologyRequestPreferredArgs:
|
|
|
1019
1537
|
@pulumi.getter
|
|
1020
1538
|
def topologies(self) -> pulumi.Input[Sequence[pulumi.Input['ExternalVolumeTopologyRequestPreferredTopologyArgs']]]:
|
|
1021
1539
|
"""
|
|
1022
|
-
|
|
1540
|
+
Defines the location for the volume.
|
|
1023
1541
|
"""
|
|
1024
1542
|
return pulumi.get(self, "topologies")
|
|
1025
1543
|
|
|
@@ -1028,15 +1546,21 @@ class ExternalVolumeTopologyRequestPreferredArgs:
|
|
|
1028
1546
|
pulumi.set(self, "topologies", value)
|
|
1029
1547
|
|
|
1030
1548
|
|
|
1549
|
+
if not MYPY:
|
|
1550
|
+
class ExternalVolumeTopologyRequestPreferredTopologyArgsDict(TypedDict):
|
|
1551
|
+
segments: pulumi.Input[Mapping[str, pulumi.Input[str]]]
|
|
1552
|
+
"""
|
|
1553
|
+
Define the attributes for the topology request.
|
|
1554
|
+
"""
|
|
1555
|
+
elif False:
|
|
1556
|
+
ExternalVolumeTopologyRequestPreferredTopologyArgsDict: TypeAlias = Mapping[str, Any]
|
|
1557
|
+
|
|
1031
1558
|
@pulumi.input_type
|
|
1032
1559
|
class ExternalVolumeTopologyRequestPreferredTopologyArgs:
|
|
1033
1560
|
def __init__(__self__, *,
|
|
1034
1561
|
segments: pulumi.Input[Mapping[str, pulumi.Input[str]]]):
|
|
1035
1562
|
"""
|
|
1036
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] segments:
|
|
1037
|
-
|
|
1038
|
-
In addition to the above arguments, the following attributes are exported and
|
|
1039
|
-
can be referenced:
|
|
1563
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] segments: Define the attributes for the topology request.
|
|
1040
1564
|
"""
|
|
1041
1565
|
pulumi.set(__self__, "segments", segments)
|
|
1042
1566
|
|
|
@@ -1044,10 +1568,7 @@ class ExternalVolumeTopologyRequestPreferredTopologyArgs:
|
|
|
1044
1568
|
@pulumi.getter
|
|
1045
1569
|
def segments(self) -> pulumi.Input[Mapping[str, pulumi.Input[str]]]:
|
|
1046
1570
|
"""
|
|
1047
|
-
|
|
1048
|
-
|
|
1049
|
-
In addition to the above arguments, the following attributes are exported and
|
|
1050
|
-
can be referenced:
|
|
1571
|
+
Define the attributes for the topology request.
|
|
1051
1572
|
"""
|
|
1052
1573
|
return pulumi.get(self, "segments")
|
|
1053
1574
|
|
|
@@ -1056,12 +1577,21 @@ class ExternalVolumeTopologyRequestPreferredTopologyArgs:
|
|
|
1056
1577
|
pulumi.set(self, "segments", value)
|
|
1057
1578
|
|
|
1058
1579
|
|
|
1580
|
+
if not MYPY:
|
|
1581
|
+
class ExternalVolumeTopologyRequestRequiredArgsDict(TypedDict):
|
|
1582
|
+
topologies: pulumi.Input[Sequence[pulumi.Input['ExternalVolumeTopologyRequestRequiredTopologyArgsDict']]]
|
|
1583
|
+
"""
|
|
1584
|
+
Defines the location for the volume.
|
|
1585
|
+
"""
|
|
1586
|
+
elif False:
|
|
1587
|
+
ExternalVolumeTopologyRequestRequiredArgsDict: TypeAlias = Mapping[str, Any]
|
|
1588
|
+
|
|
1059
1589
|
@pulumi.input_type
|
|
1060
1590
|
class ExternalVolumeTopologyRequestRequiredArgs:
|
|
1061
1591
|
def __init__(__self__, *,
|
|
1062
1592
|
topologies: pulumi.Input[Sequence[pulumi.Input['ExternalVolumeTopologyRequestRequiredTopologyArgs']]]):
|
|
1063
1593
|
"""
|
|
1064
|
-
:param pulumi.Input[Sequence[pulumi.Input['ExternalVolumeTopologyRequestRequiredTopologyArgs']]] topologies:
|
|
1594
|
+
:param pulumi.Input[Sequence[pulumi.Input['ExternalVolumeTopologyRequestRequiredTopologyArgs']]] topologies: Defines the location for the volume.
|
|
1065
1595
|
"""
|
|
1066
1596
|
pulumi.set(__self__, "topologies", topologies)
|
|
1067
1597
|
|
|
@@ -1069,7 +1599,7 @@ class ExternalVolumeTopologyRequestRequiredArgs:
|
|
|
1069
1599
|
@pulumi.getter
|
|
1070
1600
|
def topologies(self) -> pulumi.Input[Sequence[pulumi.Input['ExternalVolumeTopologyRequestRequiredTopologyArgs']]]:
|
|
1071
1601
|
"""
|
|
1072
|
-
|
|
1602
|
+
Defines the location for the volume.
|
|
1073
1603
|
"""
|
|
1074
1604
|
return pulumi.get(self, "topologies")
|
|
1075
1605
|
|
|
@@ -1078,15 +1608,21 @@ class ExternalVolumeTopologyRequestRequiredArgs:
|
|
|
1078
1608
|
pulumi.set(self, "topologies", value)
|
|
1079
1609
|
|
|
1080
1610
|
|
|
1611
|
+
if not MYPY:
|
|
1612
|
+
class ExternalVolumeTopologyRequestRequiredTopologyArgsDict(TypedDict):
|
|
1613
|
+
segments: pulumi.Input[Mapping[str, pulumi.Input[str]]]
|
|
1614
|
+
"""
|
|
1615
|
+
Define the attributes for the topology request.
|
|
1616
|
+
"""
|
|
1617
|
+
elif False:
|
|
1618
|
+
ExternalVolumeTopologyRequestRequiredTopologyArgsDict: TypeAlias = Mapping[str, Any]
|
|
1619
|
+
|
|
1081
1620
|
@pulumi.input_type
|
|
1082
1621
|
class ExternalVolumeTopologyRequestRequiredTopologyArgs:
|
|
1083
1622
|
def __init__(__self__, *,
|
|
1084
1623
|
segments: pulumi.Input[Mapping[str, pulumi.Input[str]]]):
|
|
1085
1624
|
"""
|
|
1086
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] segments:
|
|
1087
|
-
|
|
1088
|
-
In addition to the above arguments, the following attributes are exported and
|
|
1089
|
-
can be referenced:
|
|
1625
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] segments: Define the attributes for the topology request.
|
|
1090
1626
|
"""
|
|
1091
1627
|
pulumi.set(__self__, "segments", segments)
|
|
1092
1628
|
|
|
@@ -1094,10 +1630,7 @@ class ExternalVolumeTopologyRequestRequiredTopologyArgs:
|
|
|
1094
1630
|
@pulumi.getter
|
|
1095
1631
|
def segments(self) -> pulumi.Input[Mapping[str, pulumi.Input[str]]]:
|
|
1096
1632
|
"""
|
|
1097
|
-
|
|
1098
|
-
|
|
1099
|
-
In addition to the above arguments, the following attributes are exported and
|
|
1100
|
-
can be referenced:
|
|
1633
|
+
Define the attributes for the topology request.
|
|
1101
1634
|
"""
|
|
1102
1635
|
return pulumi.get(self, "segments")
|
|
1103
1636
|
|
|
@@ -1106,26 +1639,32 @@ class ExternalVolumeTopologyRequestRequiredTopologyArgs:
|
|
|
1106
1639
|
pulumi.set(self, "segments", value)
|
|
1107
1640
|
|
|
1108
1641
|
|
|
1642
|
+
if not MYPY:
|
|
1643
|
+
class JobHcl2ArgsDict(TypedDict):
|
|
1644
|
+
allow_fs: NotRequired[pulumi.Input[bool]]
|
|
1645
|
+
"""
|
|
1646
|
+
`(boolean: false)` - Set this to `true` to be able to use
|
|
1647
|
+
HCL2 filesystem functions
|
|
1648
|
+
"""
|
|
1649
|
+
vars: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
1650
|
+
"""
|
|
1651
|
+
Additional variables to use when templating the job with HCL2
|
|
1652
|
+
"""
|
|
1653
|
+
elif False:
|
|
1654
|
+
JobHcl2ArgsDict: TypeAlias = Mapping[str, Any]
|
|
1655
|
+
|
|
1109
1656
|
@pulumi.input_type
|
|
1110
1657
|
class JobHcl2Args:
|
|
1111
1658
|
def __init__(__self__, *,
|
|
1112
1659
|
allow_fs: Optional[pulumi.Input[bool]] = None,
|
|
1113
|
-
|
|
1114
|
-
vars: Optional[pulumi.Input[Mapping[str, Any]]] = None):
|
|
1660
|
+
vars: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None):
|
|
1115
1661
|
"""
|
|
1116
1662
|
:param pulumi.Input[bool] allow_fs: `(boolean: false)` - Set this to `true` to be able to use
|
|
1117
1663
|
HCL2 filesystem functions
|
|
1118
|
-
:param pulumi.Input[
|
|
1119
|
-
HCL2 by default.
|
|
1120
|
-
:param pulumi.Input[Mapping[str, Any]] vars: Additional variables to use when templating the job with HCL2
|
|
1664
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] vars: Additional variables to use when templating the job with HCL2
|
|
1121
1665
|
"""
|
|
1122
1666
|
if allow_fs is not None:
|
|
1123
1667
|
pulumi.set(__self__, "allow_fs", allow_fs)
|
|
1124
|
-
if enabled is not None:
|
|
1125
|
-
warnings.warn("""Starting with version 2.0.0 of the Nomad provider, jobs are parsed using HCL2 by default, so this field is no longer used and may be safely removed from your configuration files. Set 'hcl1 = true' if you must use HCL1 job parsing.""", DeprecationWarning)
|
|
1126
|
-
pulumi.log.warn("""enabled is deprecated: Starting with version 2.0.0 of the Nomad provider, jobs are parsed using HCL2 by default, so this field is no longer used and may be safely removed from your configuration files. Set 'hcl1 = true' if you must use HCL1 job parsing.""")
|
|
1127
|
-
if enabled is not None:
|
|
1128
|
-
pulumi.set(__self__, "enabled", enabled)
|
|
1129
1668
|
if vars is not None:
|
|
1130
1669
|
pulumi.set(__self__, "vars", vars)
|
|
1131
1670
|
|
|
@@ -1144,38 +1683,32 @@ class JobHcl2Args:
|
|
|
1144
1683
|
|
|
1145
1684
|
@property
|
|
1146
1685
|
@pulumi.getter
|
|
1147
|
-
def
|
|
1148
|
-
"""
|
|
1149
|
-
`(boolean: false)` - **Deprecated** All HCL jobs are parsed as
|
|
1150
|
-
HCL2 by default.
|
|
1151
|
-
"""
|
|
1152
|
-
warnings.warn("""Starting with version 2.0.0 of the Nomad provider, jobs are parsed using HCL2 by default, so this field is no longer used and may be safely removed from your configuration files. Set 'hcl1 = true' if you must use HCL1 job parsing.""", DeprecationWarning)
|
|
1153
|
-
pulumi.log.warn("""enabled is deprecated: Starting with version 2.0.0 of the Nomad provider, jobs are parsed using HCL2 by default, so this field is no longer used and may be safely removed from your configuration files. Set 'hcl1 = true' if you must use HCL1 job parsing.""")
|
|
1154
|
-
|
|
1155
|
-
return pulumi.get(self, "enabled")
|
|
1156
|
-
|
|
1157
|
-
@enabled.setter
|
|
1158
|
-
def enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
1159
|
-
pulumi.set(self, "enabled", value)
|
|
1160
|
-
|
|
1161
|
-
@property
|
|
1162
|
-
@pulumi.getter
|
|
1163
|
-
def vars(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
|
|
1686
|
+
def vars(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
1164
1687
|
"""
|
|
1165
1688
|
Additional variables to use when templating the job with HCL2
|
|
1166
1689
|
"""
|
|
1167
1690
|
return pulumi.get(self, "vars")
|
|
1168
1691
|
|
|
1169
1692
|
@vars.setter
|
|
1170
|
-
def vars(self, value: Optional[pulumi.Input[Mapping[str,
|
|
1693
|
+
def vars(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
1171
1694
|
pulumi.set(self, "vars", value)
|
|
1172
1695
|
|
|
1173
1696
|
|
|
1697
|
+
if not MYPY:
|
|
1698
|
+
class JobTaskGroupArgsDict(TypedDict):
|
|
1699
|
+
count: NotRequired[pulumi.Input[int]]
|
|
1700
|
+
meta: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
1701
|
+
name: NotRequired[pulumi.Input[str]]
|
|
1702
|
+
tasks: NotRequired[pulumi.Input[Sequence[pulumi.Input['JobTaskGroupTaskArgsDict']]]]
|
|
1703
|
+
volumes: NotRequired[pulumi.Input[Sequence[pulumi.Input['JobTaskGroupVolumeArgsDict']]]]
|
|
1704
|
+
elif False:
|
|
1705
|
+
JobTaskGroupArgsDict: TypeAlias = Mapping[str, Any]
|
|
1706
|
+
|
|
1174
1707
|
@pulumi.input_type
|
|
1175
1708
|
class JobTaskGroupArgs:
|
|
1176
1709
|
def __init__(__self__, *,
|
|
1177
1710
|
count: Optional[pulumi.Input[int]] = None,
|
|
1178
|
-
meta: Optional[pulumi.Input[Mapping[str,
|
|
1711
|
+
meta: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
1179
1712
|
name: Optional[pulumi.Input[str]] = None,
|
|
1180
1713
|
tasks: Optional[pulumi.Input[Sequence[pulumi.Input['JobTaskGroupTaskArgs']]]] = None,
|
|
1181
1714
|
volumes: Optional[pulumi.Input[Sequence[pulumi.Input['JobTaskGroupVolumeArgs']]]] = None):
|
|
@@ -1201,11 +1734,11 @@ class JobTaskGroupArgs:
|
|
|
1201
1734
|
|
|
1202
1735
|
@property
|
|
1203
1736
|
@pulumi.getter
|
|
1204
|
-
def meta(self) -> Optional[pulumi.Input[Mapping[str,
|
|
1737
|
+
def meta(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
1205
1738
|
return pulumi.get(self, "meta")
|
|
1206
1739
|
|
|
1207
1740
|
@meta.setter
|
|
1208
|
-
def meta(self, value: Optional[pulumi.Input[Mapping[str,
|
|
1741
|
+
def meta(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
1209
1742
|
pulumi.set(self, "meta", value)
|
|
1210
1743
|
|
|
1211
1744
|
@property
|
|
@@ -1236,11 +1769,20 @@ class JobTaskGroupArgs:
|
|
|
1236
1769
|
pulumi.set(self, "volumes", value)
|
|
1237
1770
|
|
|
1238
1771
|
|
|
1772
|
+
if not MYPY:
|
|
1773
|
+
class JobTaskGroupTaskArgsDict(TypedDict):
|
|
1774
|
+
driver: NotRequired[pulumi.Input[str]]
|
|
1775
|
+
meta: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
1776
|
+
name: NotRequired[pulumi.Input[str]]
|
|
1777
|
+
volume_mounts: NotRequired[pulumi.Input[Sequence[pulumi.Input['JobTaskGroupTaskVolumeMountArgsDict']]]]
|
|
1778
|
+
elif False:
|
|
1779
|
+
JobTaskGroupTaskArgsDict: TypeAlias = Mapping[str, Any]
|
|
1780
|
+
|
|
1239
1781
|
@pulumi.input_type
|
|
1240
1782
|
class JobTaskGroupTaskArgs:
|
|
1241
1783
|
def __init__(__self__, *,
|
|
1242
1784
|
driver: Optional[pulumi.Input[str]] = None,
|
|
1243
|
-
meta: Optional[pulumi.Input[Mapping[str,
|
|
1785
|
+
meta: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
1244
1786
|
name: Optional[pulumi.Input[str]] = None,
|
|
1245
1787
|
volume_mounts: Optional[pulumi.Input[Sequence[pulumi.Input['JobTaskGroupTaskVolumeMountArgs']]]] = None):
|
|
1246
1788
|
if driver is not None:
|
|
@@ -1263,11 +1805,11 @@ class JobTaskGroupTaskArgs:
|
|
|
1263
1805
|
|
|
1264
1806
|
@property
|
|
1265
1807
|
@pulumi.getter
|
|
1266
|
-
def meta(self) -> Optional[pulumi.Input[Mapping[str,
|
|
1808
|
+
def meta(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
1267
1809
|
return pulumi.get(self, "meta")
|
|
1268
1810
|
|
|
1269
1811
|
@meta.setter
|
|
1270
|
-
def meta(self, value: Optional[pulumi.Input[Mapping[str,
|
|
1812
|
+
def meta(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
1271
1813
|
pulumi.set(self, "meta", value)
|
|
1272
1814
|
|
|
1273
1815
|
@property
|
|
@@ -1289,6 +1831,14 @@ class JobTaskGroupTaskArgs:
|
|
|
1289
1831
|
pulumi.set(self, "volume_mounts", value)
|
|
1290
1832
|
|
|
1291
1833
|
|
|
1834
|
+
if not MYPY:
|
|
1835
|
+
class JobTaskGroupTaskVolumeMountArgsDict(TypedDict):
|
|
1836
|
+
destination: NotRequired[pulumi.Input[str]]
|
|
1837
|
+
read_only: NotRequired[pulumi.Input[bool]]
|
|
1838
|
+
volume: NotRequired[pulumi.Input[str]]
|
|
1839
|
+
elif False:
|
|
1840
|
+
JobTaskGroupTaskVolumeMountArgsDict: TypeAlias = Mapping[str, Any]
|
|
1841
|
+
|
|
1292
1842
|
@pulumi.input_type
|
|
1293
1843
|
class JobTaskGroupTaskVolumeMountArgs:
|
|
1294
1844
|
def __init__(__self__, *,
|
|
@@ -1330,6 +1880,15 @@ class JobTaskGroupTaskVolumeMountArgs:
|
|
|
1330
1880
|
pulumi.set(self, "volume", value)
|
|
1331
1881
|
|
|
1332
1882
|
|
|
1883
|
+
if not MYPY:
|
|
1884
|
+
class JobTaskGroupVolumeArgsDict(TypedDict):
|
|
1885
|
+
name: NotRequired[pulumi.Input[str]]
|
|
1886
|
+
read_only: NotRequired[pulumi.Input[bool]]
|
|
1887
|
+
source: NotRequired[pulumi.Input[str]]
|
|
1888
|
+
type: NotRequired[pulumi.Input[str]]
|
|
1889
|
+
elif False:
|
|
1890
|
+
JobTaskGroupVolumeArgsDict: TypeAlias = Mapping[str, Any]
|
|
1891
|
+
|
|
1333
1892
|
@pulumi.input_type
|
|
1334
1893
|
class JobTaskGroupVolumeArgs:
|
|
1335
1894
|
def __init__(__self__, *,
|
|
@@ -1383,6 +1942,19 @@ class JobTaskGroupVolumeArgs:
|
|
|
1383
1942
|
pulumi.set(self, "type", value)
|
|
1384
1943
|
|
|
1385
1944
|
|
|
1945
|
+
if not MYPY:
|
|
1946
|
+
class NamespaceCapabilitiesArgsDict(TypedDict):
|
|
1947
|
+
disabled_task_drivers: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
1948
|
+
"""
|
|
1949
|
+
`([]string: <optional>)` - Task drivers disabled for the namespace.
|
|
1950
|
+
"""
|
|
1951
|
+
enabled_task_drivers: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
1952
|
+
"""
|
|
1953
|
+
`([]string: <optional>)` - Task drivers enabled for the namespace.
|
|
1954
|
+
"""
|
|
1955
|
+
elif False:
|
|
1956
|
+
NamespaceCapabilitiesArgsDict: TypeAlias = Mapping[str, Any]
|
|
1957
|
+
|
|
1386
1958
|
@pulumi.input_type
|
|
1387
1959
|
class NamespaceCapabilitiesArgs:
|
|
1388
1960
|
def __init__(__self__, *,
|
|
@@ -1422,6 +1994,23 @@ class NamespaceCapabilitiesArgs:
|
|
|
1422
1994
|
pulumi.set(self, "enabled_task_drivers", value)
|
|
1423
1995
|
|
|
1424
1996
|
|
|
1997
|
+
if not MYPY:
|
|
1998
|
+
class NamespaceNodePoolConfigArgsDict(TypedDict):
|
|
1999
|
+
alloweds: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
2000
|
+
"""
|
|
2001
|
+
`([]string: <optional>)` - The list of node pools that are allowed to be used in this namespace.
|
|
2002
|
+
"""
|
|
2003
|
+
default: NotRequired[pulumi.Input[str]]
|
|
2004
|
+
"""
|
|
2005
|
+
`(string: <optional>)` - The default node pool for jobs that don't define one.
|
|
2006
|
+
"""
|
|
2007
|
+
denieds: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
2008
|
+
"""
|
|
2009
|
+
`([]string: <optional>)` - The list of node pools that are not allowed to be used in this namespace.
|
|
2010
|
+
"""
|
|
2011
|
+
elif False:
|
|
2012
|
+
NamespaceNodePoolConfigArgsDict: TypeAlias = Mapping[str, Any]
|
|
2013
|
+
|
|
1425
2014
|
@pulumi.input_type
|
|
1426
2015
|
class NamespaceNodePoolConfigArgs:
|
|
1427
2016
|
def __init__(__self__, *,
|
|
@@ -1477,6 +2066,28 @@ class NamespaceNodePoolConfigArgs:
|
|
|
1477
2066
|
pulumi.set(self, "denieds", value)
|
|
1478
2067
|
|
|
1479
2068
|
|
|
2069
|
+
if not MYPY:
|
|
2070
|
+
class NodePoolSchedulerConfigArgsDict(TypedDict):
|
|
2071
|
+
memory_oversubscription: NotRequired[pulumi.Input[str]]
|
|
2072
|
+
"""
|
|
2073
|
+
`(string)` - Whether or not memory
|
|
2074
|
+
oversubscription is enabled in the node pool. Possible values are
|
|
2075
|
+
`"enabled"` or `"disabled"`. If not defined the global cluster
|
|
2076
|
+
configuration is used.
|
|
2077
|
+
|
|
2078
|
+
> This option differs from Nomad, where it's represented as a boolean, to
|
|
2079
|
+
allow distinguishing between memory oversubscription being disabled in the
|
|
2080
|
+
node pool and this property not being set.
|
|
2081
|
+
"""
|
|
2082
|
+
scheduler_algorithm: NotRequired[pulumi.Input[str]]
|
|
2083
|
+
"""
|
|
2084
|
+
`(string)` - The scheduler algorithm used in the node
|
|
2085
|
+
pool. Possible values are `binpack` or `spread`. If not defined the global
|
|
2086
|
+
cluster configuration is used.
|
|
2087
|
+
"""
|
|
2088
|
+
elif False:
|
|
2089
|
+
NodePoolSchedulerConfigArgsDict: TypeAlias = Mapping[str, Any]
|
|
2090
|
+
|
|
1480
2091
|
@pulumi.input_type
|
|
1481
2092
|
class NodePoolSchedulerConfigArgs:
|
|
1482
2093
|
def __init__(__self__, *,
|
|
@@ -1534,6 +2145,19 @@ class NodePoolSchedulerConfigArgs:
|
|
|
1534
2145
|
pulumi.set(self, "scheduler_algorithm", value)
|
|
1535
2146
|
|
|
1536
2147
|
|
|
2148
|
+
if not MYPY:
|
|
2149
|
+
class ProviderHeaderArgsDict(TypedDict):
|
|
2150
|
+
name: pulumi.Input[str]
|
|
2151
|
+
"""
|
|
2152
|
+
The header name
|
|
2153
|
+
"""
|
|
2154
|
+
value: pulumi.Input[str]
|
|
2155
|
+
"""
|
|
2156
|
+
The header value
|
|
2157
|
+
"""
|
|
2158
|
+
elif False:
|
|
2159
|
+
ProviderHeaderArgsDict: TypeAlias = Mapping[str, Any]
|
|
2160
|
+
|
|
1537
2161
|
@pulumi.input_type
|
|
1538
2162
|
class ProviderHeaderArgs:
|
|
1539
2163
|
def __init__(__self__, *,
|
|
@@ -1571,6 +2195,21 @@ class ProviderHeaderArgs:
|
|
|
1571
2195
|
pulumi.set(self, "value", value)
|
|
1572
2196
|
|
|
1573
2197
|
|
|
2198
|
+
if not MYPY:
|
|
2199
|
+
class QuoteSpecificationLimitArgsDict(TypedDict):
|
|
2200
|
+
region: pulumi.Input[str]
|
|
2201
|
+
"""
|
|
2202
|
+
`(string: <required>)` - The region these limits should apply to.
|
|
2203
|
+
"""
|
|
2204
|
+
region_limit: pulumi.Input['QuoteSpecificationLimitRegionLimitArgsDict']
|
|
2205
|
+
"""
|
|
2206
|
+
`(block: <required>)` - The limits to enforce. This block
|
|
2207
|
+
may only be specified once in the `limits` block. Its structure is
|
|
2208
|
+
documented below.
|
|
2209
|
+
"""
|
|
2210
|
+
elif False:
|
|
2211
|
+
QuoteSpecificationLimitArgsDict: TypeAlias = Mapping[str, Any]
|
|
2212
|
+
|
|
1574
2213
|
@pulumi.input_type
|
|
1575
2214
|
class QuoteSpecificationLimitArgs:
|
|
1576
2215
|
def __init__(__self__, *,
|
|
@@ -1612,6 +2251,22 @@ class QuoteSpecificationLimitArgs:
|
|
|
1612
2251
|
pulumi.set(self, "region_limit", value)
|
|
1613
2252
|
|
|
1614
2253
|
|
|
2254
|
+
if not MYPY:
|
|
2255
|
+
class QuoteSpecificationLimitRegionLimitArgsDict(TypedDict):
|
|
2256
|
+
cpu: NotRequired[pulumi.Input[int]]
|
|
2257
|
+
"""
|
|
2258
|
+
`(int: 0)` - The amount of CPU to limit allocations to. A value of zero
|
|
2259
|
+
is treated as unlimited, and a negative value is treated as fully disallowed.
|
|
2260
|
+
"""
|
|
2261
|
+
memory_mb: NotRequired[pulumi.Input[int]]
|
|
2262
|
+
"""
|
|
2263
|
+
`(int: 0)` - The amount of memory (in megabytes) to limit
|
|
2264
|
+
allocations to. A value of zero is treated as unlimited, and a negative value
|
|
2265
|
+
is treated as fully disallowed.
|
|
2266
|
+
"""
|
|
2267
|
+
elif False:
|
|
2268
|
+
QuoteSpecificationLimitRegionLimitArgsDict: TypeAlias = Mapping[str, Any]
|
|
2269
|
+
|
|
1615
2270
|
@pulumi.input_type
|
|
1616
2271
|
class QuoteSpecificationLimitRegionLimitArgs:
|
|
1617
2272
|
def __init__(__self__, *,
|
|
@@ -1657,6 +2312,26 @@ class QuoteSpecificationLimitRegionLimitArgs:
|
|
|
1657
2312
|
pulumi.set(self, "memory_mb", value)
|
|
1658
2313
|
|
|
1659
2314
|
|
|
2315
|
+
if not MYPY:
|
|
2316
|
+
class VolumeCapabilityArgsDict(TypedDict):
|
|
2317
|
+
access_mode: pulumi.Input[str]
|
|
2318
|
+
"""
|
|
2319
|
+
`(string: <required>)` - Defines whether a volume should be available concurrently. Possible values are:
|
|
2320
|
+
- `single-node-reader-only`
|
|
2321
|
+
- `single-node-writer`
|
|
2322
|
+
- `multi-node-reader-only`
|
|
2323
|
+
- `multi-node-single-writer`
|
|
2324
|
+
- `multi-node-multi-writer`
|
|
2325
|
+
"""
|
|
2326
|
+
attachment_mode: pulumi.Input[str]
|
|
2327
|
+
"""
|
|
2328
|
+
`(string: <required>)` - The storage API that will be used by the volume. Possible values are:
|
|
2329
|
+
- `block-device`
|
|
2330
|
+
- `file-system`
|
|
2331
|
+
"""
|
|
2332
|
+
elif False:
|
|
2333
|
+
VolumeCapabilityArgsDict: TypeAlias = Mapping[str, Any]
|
|
2334
|
+
|
|
1660
2335
|
@pulumi.input_type
|
|
1661
2336
|
class VolumeCapabilityArgs:
|
|
1662
2337
|
def __init__(__self__, *,
|
|
@@ -1708,6 +2383,19 @@ class VolumeCapabilityArgs:
|
|
|
1708
2383
|
pulumi.set(self, "attachment_mode", value)
|
|
1709
2384
|
|
|
1710
2385
|
|
|
2386
|
+
if not MYPY:
|
|
2387
|
+
class VolumeMountOptionsArgsDict(TypedDict):
|
|
2388
|
+
fs_type: NotRequired[pulumi.Input[str]]
|
|
2389
|
+
"""
|
|
2390
|
+
`(string: <optional>)` - The file system type.
|
|
2391
|
+
"""
|
|
2392
|
+
mount_flags: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
2393
|
+
"""
|
|
2394
|
+
`([]string: <optional>)` - The flags passed to `mount`.
|
|
2395
|
+
"""
|
|
2396
|
+
elif False:
|
|
2397
|
+
VolumeMountOptionsArgsDict: TypeAlias = Mapping[str, Any]
|
|
2398
|
+
|
|
1711
2399
|
@pulumi.input_type
|
|
1712
2400
|
class VolumeMountOptionsArgs:
|
|
1713
2401
|
def __init__(__self__, *,
|
|
@@ -1747,6 +2435,18 @@ class VolumeMountOptionsArgs:
|
|
|
1747
2435
|
pulumi.set(self, "mount_flags", value)
|
|
1748
2436
|
|
|
1749
2437
|
|
|
2438
|
+
if not MYPY:
|
|
2439
|
+
class VolumeTopologyArgsDict(TypedDict):
|
|
2440
|
+
segments: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
2441
|
+
"""
|
|
2442
|
+
`(map[string]string)` - Define the attributes for the topology request.
|
|
2443
|
+
|
|
2444
|
+
In addition to the above arguments, the following attributes are exported and
|
|
2445
|
+
can be referenced:
|
|
2446
|
+
"""
|
|
2447
|
+
elif False:
|
|
2448
|
+
VolumeTopologyArgsDict: TypeAlias = Mapping[str, Any]
|
|
2449
|
+
|
|
1750
2450
|
@pulumi.input_type
|
|
1751
2451
|
class VolumeTopologyArgs:
|
|
1752
2452
|
def __init__(__self__, *,
|
|
@@ -1776,6 +2476,15 @@ class VolumeTopologyArgs:
|
|
|
1776
2476
|
pulumi.set(self, "segments", value)
|
|
1777
2477
|
|
|
1778
2478
|
|
|
2479
|
+
if not MYPY:
|
|
2480
|
+
class VolumeTopologyRequestArgsDict(TypedDict):
|
|
2481
|
+
required: NotRequired[pulumi.Input['VolumeTopologyRequestRequiredArgsDict']]
|
|
2482
|
+
"""
|
|
2483
|
+
`(``Topology``: <optional>)` - Required topologies indicate that the volume must be created in a location accessible from all the listed topologies.
|
|
2484
|
+
"""
|
|
2485
|
+
elif False:
|
|
2486
|
+
VolumeTopologyRequestArgsDict: TypeAlias = Mapping[str, Any]
|
|
2487
|
+
|
|
1779
2488
|
@pulumi.input_type
|
|
1780
2489
|
class VolumeTopologyRequestArgs:
|
|
1781
2490
|
def __init__(__self__, *,
|
|
@@ -1799,12 +2508,21 @@ class VolumeTopologyRequestArgs:
|
|
|
1799
2508
|
pulumi.set(self, "required", value)
|
|
1800
2509
|
|
|
1801
2510
|
|
|
2511
|
+
if not MYPY:
|
|
2512
|
+
class VolumeTopologyRequestRequiredArgsDict(TypedDict):
|
|
2513
|
+
topologies: pulumi.Input[Sequence[pulumi.Input['VolumeTopologyRequestRequiredTopologyArgsDict']]]
|
|
2514
|
+
"""
|
|
2515
|
+
Defines the location for the volume.
|
|
2516
|
+
"""
|
|
2517
|
+
elif False:
|
|
2518
|
+
VolumeTopologyRequestRequiredArgsDict: TypeAlias = Mapping[str, Any]
|
|
2519
|
+
|
|
1802
2520
|
@pulumi.input_type
|
|
1803
2521
|
class VolumeTopologyRequestRequiredArgs:
|
|
1804
2522
|
def __init__(__self__, *,
|
|
1805
2523
|
topologies: pulumi.Input[Sequence[pulumi.Input['VolumeTopologyRequestRequiredTopologyArgs']]]):
|
|
1806
2524
|
"""
|
|
1807
|
-
:param pulumi.Input[Sequence[pulumi.Input['VolumeTopologyRequestRequiredTopologyArgs']]] topologies:
|
|
2525
|
+
:param pulumi.Input[Sequence[pulumi.Input['VolumeTopologyRequestRequiredTopologyArgs']]] topologies: Defines the location for the volume.
|
|
1808
2526
|
"""
|
|
1809
2527
|
pulumi.set(__self__, "topologies", topologies)
|
|
1810
2528
|
|
|
@@ -1812,7 +2530,7 @@ class VolumeTopologyRequestRequiredArgs:
|
|
|
1812
2530
|
@pulumi.getter
|
|
1813
2531
|
def topologies(self) -> pulumi.Input[Sequence[pulumi.Input['VolumeTopologyRequestRequiredTopologyArgs']]]:
|
|
1814
2532
|
"""
|
|
1815
|
-
|
|
2533
|
+
Defines the location for the volume.
|
|
1816
2534
|
"""
|
|
1817
2535
|
return pulumi.get(self, "topologies")
|
|
1818
2536
|
|
|
@@ -1821,15 +2539,21 @@ class VolumeTopologyRequestRequiredArgs:
|
|
|
1821
2539
|
pulumi.set(self, "topologies", value)
|
|
1822
2540
|
|
|
1823
2541
|
|
|
2542
|
+
if not MYPY:
|
|
2543
|
+
class VolumeTopologyRequestRequiredTopologyArgsDict(TypedDict):
|
|
2544
|
+
segments: pulumi.Input[Mapping[str, pulumi.Input[str]]]
|
|
2545
|
+
"""
|
|
2546
|
+
Define attributes for the topology request.
|
|
2547
|
+
"""
|
|
2548
|
+
elif False:
|
|
2549
|
+
VolumeTopologyRequestRequiredTopologyArgsDict: TypeAlias = Mapping[str, Any]
|
|
2550
|
+
|
|
1824
2551
|
@pulumi.input_type
|
|
1825
2552
|
class VolumeTopologyRequestRequiredTopologyArgs:
|
|
1826
2553
|
def __init__(__self__, *,
|
|
1827
2554
|
segments: pulumi.Input[Mapping[str, pulumi.Input[str]]]):
|
|
1828
2555
|
"""
|
|
1829
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] segments:
|
|
1830
|
-
|
|
1831
|
-
In addition to the above arguments, the following attributes are exported and
|
|
1832
|
-
can be referenced:
|
|
2556
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] segments: Define attributes for the topology request.
|
|
1833
2557
|
"""
|
|
1834
2558
|
pulumi.set(__self__, "segments", segments)
|
|
1835
2559
|
|
|
@@ -1837,10 +2561,7 @@ class VolumeTopologyRequestRequiredTopologyArgs:
|
|
|
1837
2561
|
@pulumi.getter
|
|
1838
2562
|
def segments(self) -> pulumi.Input[Mapping[str, pulumi.Input[str]]]:
|
|
1839
2563
|
"""
|
|
1840
|
-
|
|
1841
|
-
|
|
1842
|
-
In addition to the above arguments, the following attributes are exported and
|
|
1843
|
-
can be referenced:
|
|
2564
|
+
Define attributes for the topology request.
|
|
1844
2565
|
"""
|
|
1845
2566
|
return pulumi.get(self, "segments")
|
|
1846
2567
|
|