pulumi-nomad 2.3.0a1714584524__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 +912 -97
- pulumi_nomad/_utilities.py +41 -5
- pulumi_nomad/acl_auth_method.py +40 -35
- pulumi_nomad/acl_binding_rule.py +5 -0
- pulumi_nomad/acl_policy.py +10 -5
- pulumi_nomad/acl_role.py +10 -5
- pulumi_nomad/acl_token.py +10 -5
- 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 -16
- pulumi_nomad/csi_volume_registration.py +21 -16
- pulumi_nomad/external_volume.py +59 -54
- pulumi_nomad/get_acl_policies.py +14 -5
- pulumi_nomad/get_acl_policy.py +15 -5
- pulumi_nomad/get_acl_role.py +15 -5
- pulumi_nomad/get_acl_roles.py +14 -5
- pulumi_nomad/get_acl_token.py +22 -5
- pulumi_nomad/get_acl_tokens.py +14 -5
- pulumi_nomad/get_allocations.py +18 -5
- pulumi_nomad/get_datacenters.py +16 -5
- pulumi_nomad/get_deployments.py +18 -6
- pulumi_nomad/get_job.py +34 -5
- pulumi_nomad/get_job_parser.py +16 -5
- pulumi_nomad/get_jwks.py +124 -0
- pulumi_nomad/get_namespace.py +18 -5
- pulumi_nomad/get_namespaces.py +12 -5
- pulumi_nomad/get_node_pool.py +16 -5
- pulumi_nomad/get_node_pools.py +16 -5
- pulumi_nomad/get_plugin.py +25 -5
- pulumi_nomad/get_plugins.py +15 -6
- pulumi_nomad/get_regions.py +12 -5
- pulumi_nomad/get_scaling_policies.py +16 -5
- pulumi_nomad/get_scaling_policy.py +19 -6
- pulumi_nomad/get_scheduler_policy.py +14 -5
- pulumi_nomad/get_variable.py +17 -6
- pulumi_nomad/get_volumes.py +21 -6
- pulumi_nomad/job.py +16 -82
- pulumi_nomad/namespace.py +29 -24
- pulumi_nomad/node_pool.py +10 -5
- pulumi_nomad/outputs.py +309 -87
- pulumi_nomad/provider.py +8 -3
- pulumi_nomad/pulumi-plugin.json +2 -1
- pulumi_nomad/quote_specification.py +24 -19
- pulumi_nomad/scheduler_config.py +5 -0
- pulumi_nomad/sentinel_policy.py +5 -0
- pulumi_nomad/variable.py +19 -14
- pulumi_nomad/volume.py +65 -72
- {pulumi_nomad-2.3.0a1714584524.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.0a1714584524.dist-info → pulumi_nomad-2.5.0a1736834448.dist-info}/WHEEL +1 -1
- pulumi_nomad-2.3.0a1714584524.dist-info/RECORD +0 -54
- {pulumi_nomad-2.3.0a1714584524.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__, *,
|
|
@@ -328,6 +619,15 @@ class AclPolicyJobAclArgs:
|
|
|
328
619
|
pulumi.set(self, "task", value)
|
|
329
620
|
|
|
330
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
|
+
|
|
331
631
|
@pulumi.input_type
|
|
332
632
|
class AclRolePolicyArgs:
|
|
333
633
|
def __init__(__self__, *,
|
|
@@ -350,6 +650,19 @@ class AclRolePolicyArgs:
|
|
|
350
650
|
pulumi.set(self, "name", value)
|
|
351
651
|
|
|
352
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
|
+
|
|
353
666
|
@pulumi.input_type
|
|
354
667
|
class AclTokenRoleArgs:
|
|
355
668
|
def __init__(__self__, *,
|
|
@@ -388,6 +701,26 @@ class AclTokenRoleArgs:
|
|
|
388
701
|
pulumi.set(self, "name", value)
|
|
389
702
|
|
|
390
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
|
+
|
|
391
724
|
@pulumi.input_type
|
|
392
725
|
class CsiVolumeCapabilityArgs:
|
|
393
726
|
def __init__(__self__, *,
|
|
@@ -439,6 +772,19 @@ class CsiVolumeCapabilityArgs:
|
|
|
439
772
|
pulumi.set(self, "attachment_mode", value)
|
|
440
773
|
|
|
441
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
|
+
|
|
442
788
|
@pulumi.input_type
|
|
443
789
|
class CsiVolumeMountOptionsArgs:
|
|
444
790
|
def __init__(__self__, *,
|
|
@@ -478,6 +824,26 @@ class CsiVolumeMountOptionsArgs:
|
|
|
478
824
|
pulumi.set(self, "mount_flags", value)
|
|
479
825
|
|
|
480
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
|
+
|
|
481
847
|
@pulumi.input_type
|
|
482
848
|
class CsiVolumeRegistrationCapabilityArgs:
|
|
483
849
|
def __init__(__self__, *,
|
|
@@ -529,6 +895,19 @@ class CsiVolumeRegistrationCapabilityArgs:
|
|
|
529
895
|
pulumi.set(self, "attachment_mode", value)
|
|
530
896
|
|
|
531
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
|
+
|
|
532
911
|
@pulumi.input_type
|
|
533
912
|
class CsiVolumeRegistrationMountOptionsArgs:
|
|
534
913
|
def __init__(__self__, *,
|
|
@@ -568,16 +947,40 @@ class CsiVolumeRegistrationMountOptionsArgs:
|
|
|
568
947
|
pulumi.set(self, "mount_flags", value)
|
|
569
948
|
|
|
570
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
|
+
|
|
571
962
|
@pulumi.input_type
|
|
572
963
|
class CsiVolumeRegistrationTopologyArgs:
|
|
573
964
|
def __init__(__self__, *,
|
|
574
965
|
segments: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None):
|
|
966
|
+
"""
|
|
967
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] segments: `(map[string]string)` - Define the attributes for the topology request.
|
|
968
|
+
|
|
969
|
+
In addition to the above arguments, the following attributes are exported and
|
|
970
|
+
can be referenced:
|
|
971
|
+
"""
|
|
575
972
|
if segments is not None:
|
|
576
973
|
pulumi.set(__self__, "segments", segments)
|
|
577
974
|
|
|
578
975
|
@property
|
|
579
976
|
@pulumi.getter
|
|
580
977
|
def segments(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
978
|
+
"""
|
|
979
|
+
`(map[string]string)` - Define the attributes for the topology request.
|
|
980
|
+
|
|
981
|
+
In addition to the above arguments, the following attributes are exported and
|
|
982
|
+
can be referenced:
|
|
983
|
+
"""
|
|
581
984
|
return pulumi.get(self, "segments")
|
|
582
985
|
|
|
583
986
|
@segments.setter
|
|
@@ -585,6 +988,15 @@ class CsiVolumeRegistrationTopologyArgs:
|
|
|
585
988
|
pulumi.set(self, "segments", value)
|
|
586
989
|
|
|
587
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
|
+
|
|
588
1000
|
@pulumi.input_type
|
|
589
1001
|
class CsiVolumeRegistrationTopologyRequestArgs:
|
|
590
1002
|
def __init__(__self__, *,
|
|
@@ -608,6 +1020,15 @@ class CsiVolumeRegistrationTopologyRequestArgs:
|
|
|
608
1020
|
pulumi.set(self, "required", value)
|
|
609
1021
|
|
|
610
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
|
+
|
|
611
1032
|
@pulumi.input_type
|
|
612
1033
|
class CsiVolumeRegistrationTopologyRequestRequiredArgs:
|
|
613
1034
|
def __init__(__self__, *,
|
|
@@ -630,6 +1051,15 @@ class CsiVolumeRegistrationTopologyRequestRequiredArgs:
|
|
|
630
1051
|
pulumi.set(self, "topologies", value)
|
|
631
1052
|
|
|
632
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
|
+
|
|
633
1063
|
@pulumi.input_type
|
|
634
1064
|
class CsiVolumeRegistrationTopologyRequestRequiredTopologyArgs:
|
|
635
1065
|
def __init__(__self__, *,
|
|
@@ -652,16 +1082,40 @@ class CsiVolumeRegistrationTopologyRequestRequiredTopologyArgs:
|
|
|
652
1082
|
pulumi.set(self, "segments", value)
|
|
653
1083
|
|
|
654
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
|
+
|
|
655
1097
|
@pulumi.input_type
|
|
656
1098
|
class CsiVolumeTopologyArgs:
|
|
657
1099
|
def __init__(__self__, *,
|
|
658
1100
|
segments: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None):
|
|
1101
|
+
"""
|
|
1102
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] segments: `(map[string]string)` - Define the attributes for the topology request.
|
|
1103
|
+
|
|
1104
|
+
In addition to the above arguments, the following attributes are exported and
|
|
1105
|
+
can be referenced:
|
|
1106
|
+
"""
|
|
659
1107
|
if segments is not None:
|
|
660
1108
|
pulumi.set(__self__, "segments", segments)
|
|
661
1109
|
|
|
662
1110
|
@property
|
|
663
1111
|
@pulumi.getter
|
|
664
1112
|
def segments(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
1113
|
+
"""
|
|
1114
|
+
`(map[string]string)` - Define the attributes for the topology request.
|
|
1115
|
+
|
|
1116
|
+
In addition to the above arguments, the following attributes are exported and
|
|
1117
|
+
can be referenced:
|
|
1118
|
+
"""
|
|
665
1119
|
return pulumi.get(self, "segments")
|
|
666
1120
|
|
|
667
1121
|
@segments.setter
|
|
@@ -669,6 +1123,19 @@ class CsiVolumeTopologyArgs:
|
|
|
669
1123
|
pulumi.set(self, "segments", value)
|
|
670
1124
|
|
|
671
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
|
+
|
|
672
1139
|
@pulumi.input_type
|
|
673
1140
|
class CsiVolumeTopologyRequestArgs:
|
|
674
1141
|
def __init__(__self__, *,
|
|
@@ -708,6 +1175,15 @@ class CsiVolumeTopologyRequestArgs:
|
|
|
708
1175
|
pulumi.set(self, "required", value)
|
|
709
1176
|
|
|
710
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
|
+
|
|
711
1187
|
@pulumi.input_type
|
|
712
1188
|
class CsiVolumeTopologyRequestPreferredArgs:
|
|
713
1189
|
def __init__(__self__, *,
|
|
@@ -730,6 +1206,15 @@ class CsiVolumeTopologyRequestPreferredArgs:
|
|
|
730
1206
|
pulumi.set(self, "topologies", value)
|
|
731
1207
|
|
|
732
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
|
+
|
|
733
1218
|
@pulumi.input_type
|
|
734
1219
|
class CsiVolumeTopologyRequestPreferredTopologyArgs:
|
|
735
1220
|
def __init__(__self__, *,
|
|
@@ -752,6 +1237,15 @@ class CsiVolumeTopologyRequestPreferredTopologyArgs:
|
|
|
752
1237
|
pulumi.set(self, "segments", value)
|
|
753
1238
|
|
|
754
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
|
+
|
|
755
1249
|
@pulumi.input_type
|
|
756
1250
|
class CsiVolumeTopologyRequestRequiredArgs:
|
|
757
1251
|
def __init__(__self__, *,
|
|
@@ -774,6 +1268,15 @@ class CsiVolumeTopologyRequestRequiredArgs:
|
|
|
774
1268
|
pulumi.set(self, "topologies", value)
|
|
775
1269
|
|
|
776
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
|
+
|
|
777
1280
|
@pulumi.input_type
|
|
778
1281
|
class CsiVolumeTopologyRequestRequiredTopologyArgs:
|
|
779
1282
|
def __init__(__self__, *,
|
|
@@ -796,6 +1299,26 @@ class CsiVolumeTopologyRequestRequiredTopologyArgs:
|
|
|
796
1299
|
pulumi.set(self, "segments", value)
|
|
797
1300
|
|
|
798
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
|
+
|
|
799
1322
|
@pulumi.input_type
|
|
800
1323
|
class ExternalVolumeCapabilityArgs:
|
|
801
1324
|
def __init__(__self__, *,
|
|
@@ -847,6 +1370,19 @@ class ExternalVolumeCapabilityArgs:
|
|
|
847
1370
|
pulumi.set(self, "attachment_mode", value)
|
|
848
1371
|
|
|
849
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
|
+
|
|
850
1386
|
@pulumi.input_type
|
|
851
1387
|
class ExternalVolumeMountOptionsArgs:
|
|
852
1388
|
def __init__(__self__, *,
|
|
@@ -886,16 +1422,40 @@ class ExternalVolumeMountOptionsArgs:
|
|
|
886
1422
|
pulumi.set(self, "mount_flags", value)
|
|
887
1423
|
|
|
888
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
|
+
|
|
889
1437
|
@pulumi.input_type
|
|
890
1438
|
class ExternalVolumeTopologyArgs:
|
|
891
1439
|
def __init__(__self__, *,
|
|
892
1440
|
segments: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None):
|
|
1441
|
+
"""
|
|
1442
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] segments: `(map[string]string)` - Define the attributes for the topology request.
|
|
1443
|
+
|
|
1444
|
+
In addition to the above arguments, the following attributes are exported and
|
|
1445
|
+
can be referenced:
|
|
1446
|
+
"""
|
|
893
1447
|
if segments is not None:
|
|
894
1448
|
pulumi.set(__self__, "segments", segments)
|
|
895
1449
|
|
|
896
1450
|
@property
|
|
897
1451
|
@pulumi.getter
|
|
898
1452
|
def segments(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
1453
|
+
"""
|
|
1454
|
+
`(map[string]string)` - Define the attributes for the topology request.
|
|
1455
|
+
|
|
1456
|
+
In addition to the above arguments, the following attributes are exported and
|
|
1457
|
+
can be referenced:
|
|
1458
|
+
"""
|
|
899
1459
|
return pulumi.get(self, "segments")
|
|
900
1460
|
|
|
901
1461
|
@segments.setter
|
|
@@ -903,6 +1463,19 @@ class ExternalVolumeTopologyArgs:
|
|
|
903
1463
|
pulumi.set(self, "segments", value)
|
|
904
1464
|
|
|
905
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
|
+
|
|
906
1479
|
@pulumi.input_type
|
|
907
1480
|
class ExternalVolumeTopologyRequestArgs:
|
|
908
1481
|
def __init__(__self__, *,
|
|
@@ -942,6 +1515,15 @@ class ExternalVolumeTopologyRequestArgs:
|
|
|
942
1515
|
pulumi.set(self, "required", value)
|
|
943
1516
|
|
|
944
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
|
+
|
|
945
1527
|
@pulumi.input_type
|
|
946
1528
|
class ExternalVolumeTopologyRequestPreferredArgs:
|
|
947
1529
|
def __init__(__self__, *,
|
|
@@ -964,6 +1546,15 @@ class ExternalVolumeTopologyRequestPreferredArgs:
|
|
|
964
1546
|
pulumi.set(self, "topologies", value)
|
|
965
1547
|
|
|
966
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
|
+
|
|
967
1558
|
@pulumi.input_type
|
|
968
1559
|
class ExternalVolumeTopologyRequestPreferredTopologyArgs:
|
|
969
1560
|
def __init__(__self__, *,
|
|
@@ -986,6 +1577,15 @@ class ExternalVolumeTopologyRequestPreferredTopologyArgs:
|
|
|
986
1577
|
pulumi.set(self, "segments", value)
|
|
987
1578
|
|
|
988
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
|
+
|
|
989
1589
|
@pulumi.input_type
|
|
990
1590
|
class ExternalVolumeTopologyRequestRequiredArgs:
|
|
991
1591
|
def __init__(__self__, *,
|
|
@@ -1008,6 +1608,15 @@ class ExternalVolumeTopologyRequestRequiredArgs:
|
|
|
1008
1608
|
pulumi.set(self, "topologies", value)
|
|
1009
1609
|
|
|
1010
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
|
+
|
|
1011
1620
|
@pulumi.input_type
|
|
1012
1621
|
class ExternalVolumeTopologyRequestRequiredTopologyArgs:
|
|
1013
1622
|
def __init__(__self__, *,
|
|
@@ -1030,26 +1639,32 @@ class ExternalVolumeTopologyRequestRequiredTopologyArgs:
|
|
|
1030
1639
|
pulumi.set(self, "segments", value)
|
|
1031
1640
|
|
|
1032
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
|
+
|
|
1033
1656
|
@pulumi.input_type
|
|
1034
1657
|
class JobHcl2Args:
|
|
1035
1658
|
def __init__(__self__, *,
|
|
1036
1659
|
allow_fs: Optional[pulumi.Input[bool]] = None,
|
|
1037
|
-
|
|
1038
|
-
vars: Optional[pulumi.Input[Mapping[str, Any]]] = None):
|
|
1660
|
+
vars: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None):
|
|
1039
1661
|
"""
|
|
1040
1662
|
:param pulumi.Input[bool] allow_fs: `(boolean: false)` - Set this to `true` to be able to use
|
|
1041
1663
|
HCL2 filesystem functions
|
|
1042
|
-
:param pulumi.Input[
|
|
1043
|
-
HCL2 by default.
|
|
1044
|
-
: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
|
|
1045
1665
|
"""
|
|
1046
1666
|
if allow_fs is not None:
|
|
1047
1667
|
pulumi.set(__self__, "allow_fs", allow_fs)
|
|
1048
|
-
if enabled is not None:
|
|
1049
|
-
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)
|
|
1050
|
-
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.""")
|
|
1051
|
-
if enabled is not None:
|
|
1052
|
-
pulumi.set(__self__, "enabled", enabled)
|
|
1053
1668
|
if vars is not None:
|
|
1054
1669
|
pulumi.set(__self__, "vars", vars)
|
|
1055
1670
|
|
|
@@ -1068,38 +1683,32 @@ class JobHcl2Args:
|
|
|
1068
1683
|
|
|
1069
1684
|
@property
|
|
1070
1685
|
@pulumi.getter
|
|
1071
|
-
def
|
|
1072
|
-
"""
|
|
1073
|
-
`(boolean: false)` - **Deprecated** All HCL jobs are parsed as
|
|
1074
|
-
HCL2 by default.
|
|
1075
|
-
"""
|
|
1076
|
-
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)
|
|
1077
|
-
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.""")
|
|
1078
|
-
|
|
1079
|
-
return pulumi.get(self, "enabled")
|
|
1080
|
-
|
|
1081
|
-
@enabled.setter
|
|
1082
|
-
def enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
1083
|
-
pulumi.set(self, "enabled", value)
|
|
1084
|
-
|
|
1085
|
-
@property
|
|
1086
|
-
@pulumi.getter
|
|
1087
|
-
def vars(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
|
|
1686
|
+
def vars(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
1088
1687
|
"""
|
|
1089
1688
|
Additional variables to use when templating the job with HCL2
|
|
1090
1689
|
"""
|
|
1091
1690
|
return pulumi.get(self, "vars")
|
|
1092
1691
|
|
|
1093
1692
|
@vars.setter
|
|
1094
|
-
def vars(self, value: Optional[pulumi.Input[Mapping[str,
|
|
1693
|
+
def vars(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
1095
1694
|
pulumi.set(self, "vars", value)
|
|
1096
1695
|
|
|
1097
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
|
+
|
|
1098
1707
|
@pulumi.input_type
|
|
1099
1708
|
class JobTaskGroupArgs:
|
|
1100
1709
|
def __init__(__self__, *,
|
|
1101
1710
|
count: Optional[pulumi.Input[int]] = None,
|
|
1102
|
-
meta: Optional[pulumi.Input[Mapping[str,
|
|
1711
|
+
meta: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
1103
1712
|
name: Optional[pulumi.Input[str]] = None,
|
|
1104
1713
|
tasks: Optional[pulumi.Input[Sequence[pulumi.Input['JobTaskGroupTaskArgs']]]] = None,
|
|
1105
1714
|
volumes: Optional[pulumi.Input[Sequence[pulumi.Input['JobTaskGroupVolumeArgs']]]] = None):
|
|
@@ -1125,11 +1734,11 @@ class JobTaskGroupArgs:
|
|
|
1125
1734
|
|
|
1126
1735
|
@property
|
|
1127
1736
|
@pulumi.getter
|
|
1128
|
-
def meta(self) -> Optional[pulumi.Input[Mapping[str,
|
|
1737
|
+
def meta(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
1129
1738
|
return pulumi.get(self, "meta")
|
|
1130
1739
|
|
|
1131
1740
|
@meta.setter
|
|
1132
|
-
def meta(self, value: Optional[pulumi.Input[Mapping[str,
|
|
1741
|
+
def meta(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
1133
1742
|
pulumi.set(self, "meta", value)
|
|
1134
1743
|
|
|
1135
1744
|
@property
|
|
@@ -1160,11 +1769,20 @@ class JobTaskGroupArgs:
|
|
|
1160
1769
|
pulumi.set(self, "volumes", value)
|
|
1161
1770
|
|
|
1162
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
|
+
|
|
1163
1781
|
@pulumi.input_type
|
|
1164
1782
|
class JobTaskGroupTaskArgs:
|
|
1165
1783
|
def __init__(__self__, *,
|
|
1166
1784
|
driver: Optional[pulumi.Input[str]] = None,
|
|
1167
|
-
meta: Optional[pulumi.Input[Mapping[str,
|
|
1785
|
+
meta: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
1168
1786
|
name: Optional[pulumi.Input[str]] = None,
|
|
1169
1787
|
volume_mounts: Optional[pulumi.Input[Sequence[pulumi.Input['JobTaskGroupTaskVolumeMountArgs']]]] = None):
|
|
1170
1788
|
if driver is not None:
|
|
@@ -1187,11 +1805,11 @@ class JobTaskGroupTaskArgs:
|
|
|
1187
1805
|
|
|
1188
1806
|
@property
|
|
1189
1807
|
@pulumi.getter
|
|
1190
|
-
def meta(self) -> Optional[pulumi.Input[Mapping[str,
|
|
1808
|
+
def meta(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
1191
1809
|
return pulumi.get(self, "meta")
|
|
1192
1810
|
|
|
1193
1811
|
@meta.setter
|
|
1194
|
-
def meta(self, value: Optional[pulumi.Input[Mapping[str,
|
|
1812
|
+
def meta(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
1195
1813
|
pulumi.set(self, "meta", value)
|
|
1196
1814
|
|
|
1197
1815
|
@property
|
|
@@ -1213,6 +1831,14 @@ class JobTaskGroupTaskArgs:
|
|
|
1213
1831
|
pulumi.set(self, "volume_mounts", value)
|
|
1214
1832
|
|
|
1215
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
|
+
|
|
1216
1842
|
@pulumi.input_type
|
|
1217
1843
|
class JobTaskGroupTaskVolumeMountArgs:
|
|
1218
1844
|
def __init__(__self__, *,
|
|
@@ -1254,6 +1880,15 @@ class JobTaskGroupTaskVolumeMountArgs:
|
|
|
1254
1880
|
pulumi.set(self, "volume", value)
|
|
1255
1881
|
|
|
1256
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
|
+
|
|
1257
1892
|
@pulumi.input_type
|
|
1258
1893
|
class JobTaskGroupVolumeArgs:
|
|
1259
1894
|
def __init__(__self__, *,
|
|
@@ -1307,6 +1942,19 @@ class JobTaskGroupVolumeArgs:
|
|
|
1307
1942
|
pulumi.set(self, "type", value)
|
|
1308
1943
|
|
|
1309
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
|
+
|
|
1310
1958
|
@pulumi.input_type
|
|
1311
1959
|
class NamespaceCapabilitiesArgs:
|
|
1312
1960
|
def __init__(__self__, *,
|
|
@@ -1346,6 +1994,23 @@ class NamespaceCapabilitiesArgs:
|
|
|
1346
1994
|
pulumi.set(self, "enabled_task_drivers", value)
|
|
1347
1995
|
|
|
1348
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
|
+
|
|
1349
2014
|
@pulumi.input_type
|
|
1350
2015
|
class NamespaceNodePoolConfigArgs:
|
|
1351
2016
|
def __init__(__self__, *,
|
|
@@ -1401,6 +2066,28 @@ class NamespaceNodePoolConfigArgs:
|
|
|
1401
2066
|
pulumi.set(self, "denieds", value)
|
|
1402
2067
|
|
|
1403
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
|
+
|
|
1404
2091
|
@pulumi.input_type
|
|
1405
2092
|
class NodePoolSchedulerConfigArgs:
|
|
1406
2093
|
def __init__(__self__, *,
|
|
@@ -1458,6 +2145,19 @@ class NodePoolSchedulerConfigArgs:
|
|
|
1458
2145
|
pulumi.set(self, "scheduler_algorithm", value)
|
|
1459
2146
|
|
|
1460
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
|
+
|
|
1461
2161
|
@pulumi.input_type
|
|
1462
2162
|
class ProviderHeaderArgs:
|
|
1463
2163
|
def __init__(__self__, *,
|
|
@@ -1495,6 +2195,21 @@ class ProviderHeaderArgs:
|
|
|
1495
2195
|
pulumi.set(self, "value", value)
|
|
1496
2196
|
|
|
1497
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
|
+
|
|
1498
2213
|
@pulumi.input_type
|
|
1499
2214
|
class QuoteSpecificationLimitArgs:
|
|
1500
2215
|
def __init__(__self__, *,
|
|
@@ -1536,6 +2251,22 @@ class QuoteSpecificationLimitArgs:
|
|
|
1536
2251
|
pulumi.set(self, "region_limit", value)
|
|
1537
2252
|
|
|
1538
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
|
+
|
|
1539
2270
|
@pulumi.input_type
|
|
1540
2271
|
class QuoteSpecificationLimitRegionLimitArgs:
|
|
1541
2272
|
def __init__(__self__, *,
|
|
@@ -1581,6 +2312,26 @@ class QuoteSpecificationLimitRegionLimitArgs:
|
|
|
1581
2312
|
pulumi.set(self, "memory_mb", value)
|
|
1582
2313
|
|
|
1583
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
|
+
|
|
1584
2335
|
@pulumi.input_type
|
|
1585
2336
|
class VolumeCapabilityArgs:
|
|
1586
2337
|
def __init__(__self__, *,
|
|
@@ -1632,6 +2383,19 @@ class VolumeCapabilityArgs:
|
|
|
1632
2383
|
pulumi.set(self, "attachment_mode", value)
|
|
1633
2384
|
|
|
1634
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
|
+
|
|
1635
2399
|
@pulumi.input_type
|
|
1636
2400
|
class VolumeMountOptionsArgs:
|
|
1637
2401
|
def __init__(__self__, *,
|
|
@@ -1671,16 +2435,40 @@ class VolumeMountOptionsArgs:
|
|
|
1671
2435
|
pulumi.set(self, "mount_flags", value)
|
|
1672
2436
|
|
|
1673
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
|
+
|
|
1674
2450
|
@pulumi.input_type
|
|
1675
2451
|
class VolumeTopologyArgs:
|
|
1676
2452
|
def __init__(__self__, *,
|
|
1677
2453
|
segments: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None):
|
|
2454
|
+
"""
|
|
2455
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] segments: `(map[string]string)` - Define the attributes for the topology request.
|
|
2456
|
+
|
|
2457
|
+
In addition to the above arguments, the following attributes are exported and
|
|
2458
|
+
can be referenced:
|
|
2459
|
+
"""
|
|
1678
2460
|
if segments is not None:
|
|
1679
2461
|
pulumi.set(__self__, "segments", segments)
|
|
1680
2462
|
|
|
1681
2463
|
@property
|
|
1682
2464
|
@pulumi.getter
|
|
1683
2465
|
def segments(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
2466
|
+
"""
|
|
2467
|
+
`(map[string]string)` - Define the attributes for the topology request.
|
|
2468
|
+
|
|
2469
|
+
In addition to the above arguments, the following attributes are exported and
|
|
2470
|
+
can be referenced:
|
|
2471
|
+
"""
|
|
1684
2472
|
return pulumi.get(self, "segments")
|
|
1685
2473
|
|
|
1686
2474
|
@segments.setter
|
|
@@ -1688,6 +2476,15 @@ class VolumeTopologyArgs:
|
|
|
1688
2476
|
pulumi.set(self, "segments", value)
|
|
1689
2477
|
|
|
1690
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
|
+
|
|
1691
2488
|
@pulumi.input_type
|
|
1692
2489
|
class VolumeTopologyRequestArgs:
|
|
1693
2490
|
def __init__(__self__, *,
|
|
@@ -1711,6 +2508,15 @@ class VolumeTopologyRequestArgs:
|
|
|
1711
2508
|
pulumi.set(self, "required", value)
|
|
1712
2509
|
|
|
1713
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
|
+
|
|
1714
2520
|
@pulumi.input_type
|
|
1715
2521
|
class VolumeTopologyRequestRequiredArgs:
|
|
1716
2522
|
def __init__(__self__, *,
|
|
@@ -1733,6 +2539,15 @@ class VolumeTopologyRequestRequiredArgs:
|
|
|
1733
2539
|
pulumi.set(self, "topologies", value)
|
|
1734
2540
|
|
|
1735
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
|
+
|
|
1736
2551
|
@pulumi.input_type
|
|
1737
2552
|
class VolumeTopologyRequestRequiredTopologyArgs:
|
|
1738
2553
|
def __init__(__self__, *,
|