pulumi-nomad 2.4.3__py3-none-any.whl → 2.5.0__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 +20 -0
- pulumi_nomad/_inputs.py +1056 -378
- pulumi_nomad/acl_auth_method.py +85 -84
- pulumi_nomad/acl_binding_rule.py +71 -70
- pulumi_nomad/acl_policy.py +57 -49
- pulumi_nomad/acl_role.py +29 -28
- pulumi_nomad/acl_token.py +99 -98
- pulumi_nomad/config/__init__.py +1 -0
- pulumi_nomad/config/__init__.pyi +1 -10
- pulumi_nomad/config/outputs.py +7 -6
- pulumi_nomad/config/vars.py +1 -14
- pulumi_nomad/csi_volume.py +231 -202
- pulumi_nomad/csi_volume_registration.py +210 -209
- pulumi_nomad/dynamic_host_volume.py +1005 -0
- pulumi_nomad/dynamic_host_volume_registration.py +740 -0
- pulumi_nomad/external_volume.py +195 -194
- pulumi_nomad/get_acl_policies.py +7 -6
- pulumi_nomad/get_acl_policy.py +9 -8
- pulumi_nomad/get_acl_role.py +8 -7
- pulumi_nomad/get_acl_roles.py +7 -6
- pulumi_nomad/get_acl_token.py +15 -14
- pulumi_nomad/get_acl_tokens.py +7 -6
- pulumi_nomad/get_allocations.py +17 -16
- pulumi_nomad/get_datacenters.py +13 -12
- pulumi_nomad/get_deployments.py +3 -2
- pulumi_nomad/get_dynamic_host_volume.py +353 -0
- pulumi_nomad/get_job.py +28 -27
- pulumi_nomad/get_job_parser.py +13 -12
- pulumi_nomad/get_jwks.py +3 -2
- pulumi_nomad/get_namespace.py +10 -9
- pulumi_nomad/get_namespaces.py +3 -2
- pulumi_nomad/get_node_pool.py +9 -8
- pulumi_nomad/get_node_pools.py +12 -11
- pulumi_nomad/get_plugin.py +24 -23
- pulumi_nomad/get_plugins.py +6 -5
- pulumi_nomad/get_regions.py +3 -2
- pulumi_nomad/get_scaling_policies.py +12 -11
- pulumi_nomad/get_scaling_policy.py +12 -11
- pulumi_nomad/get_scheduler_policy.py +5 -4
- pulumi_nomad/get_variable.py +13 -12
- pulumi_nomad/get_volumes.py +23 -22
- pulumi_nomad/job.py +193 -302
- pulumi_nomad/namespace.py +57 -56
- pulumi_nomad/node_pool.py +43 -42
- pulumi_nomad/outputs.py +1030 -451
- pulumi_nomad/provider.py +95 -152
- pulumi_nomad/pulumi-plugin.json +1 -1
- pulumi_nomad/quote_specification.py +29 -28
- pulumi_nomad/scheduler_config.py +43 -42
- pulumi_nomad/sentinel_policy.py +71 -70
- pulumi_nomad/variable.py +43 -42
- pulumi_nomad/volume.py +209 -208
- {pulumi_nomad-2.4.3.dist-info → pulumi_nomad-2.5.0.dist-info}/METADATA +2 -2
- pulumi_nomad-2.5.0.dist-info/RECORD +58 -0
- {pulumi_nomad-2.4.3.dist-info → pulumi_nomad-2.5.0.dist-info}/WHEEL +1 -1
- pulumi_nomad-2.4.3.dist-info/RECORD +0 -55
- {pulumi_nomad-2.4.3.dist-info → pulumi_nomad-2.5.0.dist-info}/top_level.txt +0 -0
pulumi_nomad/_inputs.py
CHANGED
|
@@ -2,6 +2,7 @@
|
|
|
2
2
|
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
|
|
3
3
|
# *** Do not edit by hand unless you're certain you know what you are doing! ***
|
|
4
4
|
|
|
5
|
+
import builtins
|
|
5
6
|
import copy
|
|
6
7
|
import warnings
|
|
7
8
|
import sys
|
|
@@ -17,6 +18,10 @@ from . import _utilities
|
|
|
17
18
|
__all__ = [
|
|
18
19
|
'AclAuthMethodConfigArgs',
|
|
19
20
|
'AclAuthMethodConfigArgsDict',
|
|
21
|
+
'AclAuthMethodConfigOidcClientAssertionArgs',
|
|
22
|
+
'AclAuthMethodConfigOidcClientAssertionArgsDict',
|
|
23
|
+
'AclAuthMethodConfigOidcClientAssertionPrivateKeyArgs',
|
|
24
|
+
'AclAuthMethodConfigOidcClientAssertionPrivateKeyArgsDict',
|
|
20
25
|
'AclPolicyJobAclArgs',
|
|
21
26
|
'AclPolicyJobAclArgsDict',
|
|
22
27
|
'AclRolePolicyArgs',
|
|
@@ -51,6 +56,14 @@ __all__ = [
|
|
|
51
56
|
'CsiVolumeTopologyRequestRequiredArgsDict',
|
|
52
57
|
'CsiVolumeTopologyRequestRequiredTopologyArgs',
|
|
53
58
|
'CsiVolumeTopologyRequestRequiredTopologyArgsDict',
|
|
59
|
+
'DynamicHostVolumeCapabilityArgs',
|
|
60
|
+
'DynamicHostVolumeCapabilityArgsDict',
|
|
61
|
+
'DynamicHostVolumeConstraintArgs',
|
|
62
|
+
'DynamicHostVolumeConstraintArgsDict',
|
|
63
|
+
'DynamicHostVolumeRegistrationCapabilityArgs',
|
|
64
|
+
'DynamicHostVolumeRegistrationCapabilityArgsDict',
|
|
65
|
+
'DynamicHostVolumeRegistrationConstraintArgs',
|
|
66
|
+
'DynamicHostVolumeRegistrationConstraintArgsDict',
|
|
54
67
|
'ExternalVolumeCapabilityArgs',
|
|
55
68
|
'ExternalVolumeCapabilityArgsDict',
|
|
56
69
|
'ExternalVolumeMountOptionsArgs',
|
|
@@ -107,155 +120,183 @@ MYPY = False
|
|
|
107
120
|
|
|
108
121
|
if not MYPY:
|
|
109
122
|
class AclAuthMethodConfigArgsDict(TypedDict):
|
|
110
|
-
allowed_redirect_uris: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
123
|
+
allowed_redirect_uris: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
|
|
111
124
|
"""
|
|
112
125
|
`([]string: <optional>)` - A list of allowed values
|
|
113
126
|
that can be used for the redirect URI.
|
|
114
127
|
"""
|
|
115
|
-
bound_audiences: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
128
|
+
bound_audiences: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
|
|
116
129
|
"""
|
|
117
130
|
`([]string: <optional>)` - List of auth claims that are
|
|
118
131
|
valid for login.
|
|
119
132
|
"""
|
|
120
|
-
bound_issuers: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
133
|
+
bound_issuers: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
|
|
121
134
|
"""
|
|
122
135
|
`([]string: <optional>)` - The value against which to match
|
|
123
136
|
the iss claim in a JWT.
|
|
124
137
|
"""
|
|
125
|
-
claim_mappings: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
138
|
+
claim_mappings: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]
|
|
126
139
|
"""
|
|
127
140
|
Mappings of claims (key) that will be copied to a metadata field (value).
|
|
128
141
|
"""
|
|
129
|
-
clock_skew_leeway: NotRequired[pulumi.Input[str]]
|
|
142
|
+
clock_skew_leeway: NotRequired[pulumi.Input[builtins.str]]
|
|
130
143
|
"""
|
|
131
144
|
`(string: <optional>)` - Duration of leeway when validating
|
|
132
145
|
all claims in the form of a time duration such as "5m" or "1h".
|
|
133
146
|
"""
|
|
134
|
-
discovery_ca_pems: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
147
|
+
discovery_ca_pems: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
|
|
135
148
|
"""
|
|
136
149
|
`([]string: <optional>)` - PEM encoded CA certs for use
|
|
137
150
|
by the TLS client used to talk with the OIDC Discovery URL.
|
|
138
151
|
"""
|
|
139
|
-
expiration_leeway: NotRequired[pulumi.Input[str]]
|
|
152
|
+
expiration_leeway: NotRequired[pulumi.Input[builtins.str]]
|
|
140
153
|
"""
|
|
141
154
|
`(string: <optional>)` - Duration of leeway when validating
|
|
142
155
|
expiration of a JWT in the form of a time duration such as "5m" or "1h".
|
|
143
156
|
"""
|
|
144
|
-
jwks_ca_cert: NotRequired[pulumi.Input[str]]
|
|
157
|
+
jwks_ca_cert: NotRequired[pulumi.Input[builtins.str]]
|
|
145
158
|
"""
|
|
146
159
|
`(string: <optional>)` - PEM encoded CA cert for use by the
|
|
147
160
|
TLS client used to talk with the JWKS server.
|
|
148
161
|
"""
|
|
149
|
-
jwks_url: NotRequired[pulumi.Input[str]]
|
|
162
|
+
jwks_url: NotRequired[pulumi.Input[builtins.str]]
|
|
150
163
|
"""
|
|
151
164
|
`(string: <optional>)` - JSON Web Key Sets url for authenticating
|
|
152
165
|
signatures.
|
|
153
166
|
"""
|
|
154
|
-
jwt_validation_pub_keys: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
167
|
+
jwt_validation_pub_keys: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
|
|
155
168
|
"""
|
|
156
169
|
`([]string: <optional>)` - List of PEM-encoded
|
|
157
170
|
public keys to use to authenticate signatures locally.
|
|
158
171
|
"""
|
|
159
|
-
list_claim_mappings: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
172
|
+
list_claim_mappings: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]
|
|
160
173
|
"""
|
|
161
174
|
Mappings of list claims (key) that will be copied to a metadata field (value).
|
|
162
175
|
"""
|
|
163
|
-
not_before_leeway: NotRequired[pulumi.Input[str]]
|
|
176
|
+
not_before_leeway: NotRequired[pulumi.Input[builtins.str]]
|
|
164
177
|
"""
|
|
165
178
|
`(string: <optional>)` - Duration of leeway when validating
|
|
166
179
|
not before values of a token in the form of a time duration such as "5m" or "1h".
|
|
167
180
|
"""
|
|
168
|
-
|
|
181
|
+
oidc_client_assertion: NotRequired[pulumi.Input['AclAuthMethodConfigOidcClientAssertionArgsDict']]
|
|
182
|
+
"""
|
|
183
|
+
`(OIDCClientAssertion: <optional>)` - Optionally
|
|
184
|
+
send a signed JWT ("[private key jwt][]") as a client assertion to the OIDC
|
|
185
|
+
provider. Browse to the [OIDC concepts][concepts-assertions] page to learn
|
|
186
|
+
more.
|
|
187
|
+
"""
|
|
188
|
+
oidc_client_id: NotRequired[pulumi.Input[builtins.str]]
|
|
169
189
|
"""
|
|
170
190
|
`(string: <optional>)` - The OAuth Client ID configured
|
|
171
191
|
with the OIDC provider.
|
|
172
192
|
"""
|
|
173
|
-
oidc_client_secret: NotRequired[pulumi.Input[str]]
|
|
193
|
+
oidc_client_secret: NotRequired[pulumi.Input[builtins.str]]
|
|
174
194
|
"""
|
|
175
195
|
`(string: <optional>)` - The OAuth Client Secret
|
|
176
196
|
configured with the OIDC provider.
|
|
177
197
|
"""
|
|
178
|
-
oidc_disable_userinfo: NotRequired[pulumi.Input[bool]]
|
|
198
|
+
oidc_disable_userinfo: NotRequired[pulumi.Input[builtins.bool]]
|
|
179
199
|
"""
|
|
180
200
|
`(bool: false)` - When set to `true`, Nomad will
|
|
181
201
|
not make a request to the identity provider to get OIDC `UserInfo`.
|
|
182
202
|
You may wish to set this if your identity provider doesn't send any
|
|
183
203
|
additional claims from the `UserInfo` endpoint.
|
|
184
204
|
"""
|
|
185
|
-
oidc_discovery_url: NotRequired[pulumi.Input[str]]
|
|
205
|
+
oidc_discovery_url: NotRequired[pulumi.Input[builtins.str]]
|
|
186
206
|
"""
|
|
187
207
|
`(string: <optional>)` - The OIDC Discovery URL,
|
|
188
208
|
without any .well-known component (base path).
|
|
189
209
|
"""
|
|
190
|
-
|
|
210
|
+
oidc_enable_pkce: NotRequired[pulumi.Input[builtins.bool]]
|
|
211
|
+
"""
|
|
212
|
+
`(bool: false)` - When set to `true`, Nomad will include
|
|
213
|
+
[PKCE][] verification in the auth flow. Even with PKCE enabled in Nomad,
|
|
214
|
+
you may still need to enable it in your OIDC provider.
|
|
215
|
+
"""
|
|
216
|
+
oidc_scopes: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
|
|
191
217
|
"""
|
|
192
218
|
`([]string: <optional>)` - List of OIDC scopes.
|
|
193
219
|
"""
|
|
194
|
-
signing_algs: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
220
|
+
signing_algs: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
|
|
195
221
|
"""
|
|
196
222
|
`([]string: <optional>)` - A list of supported signing
|
|
197
223
|
algorithms.
|
|
198
224
|
"""
|
|
225
|
+
verbose_logging: NotRequired[pulumi.Input[builtins.bool]]
|
|
226
|
+
"""
|
|
227
|
+
Enable OIDC verbose logging on the Nomad server.
|
|
228
|
+
"""
|
|
199
229
|
elif False:
|
|
200
230
|
AclAuthMethodConfigArgsDict: TypeAlias = Mapping[str, Any]
|
|
201
231
|
|
|
202
232
|
@pulumi.input_type
|
|
203
233
|
class AclAuthMethodConfigArgs:
|
|
204
234
|
def __init__(__self__, *,
|
|
205
|
-
allowed_redirect_uris: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
206
|
-
bound_audiences: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
207
|
-
bound_issuers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
208
|
-
claim_mappings: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
209
|
-
clock_skew_leeway: Optional[pulumi.Input[str]] = None,
|
|
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,
|
|
215
|
-
list_claim_mappings: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
216
|
-
not_before_leeway: Optional[pulumi.Input[str]] = None,
|
|
217
|
-
|
|
218
|
-
|
|
219
|
-
|
|
220
|
-
|
|
221
|
-
|
|
222
|
-
|
|
223
|
-
|
|
224
|
-
|
|
235
|
+
allowed_redirect_uris: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
236
|
+
bound_audiences: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
237
|
+
bound_issuers: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
238
|
+
claim_mappings: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None,
|
|
239
|
+
clock_skew_leeway: Optional[pulumi.Input[builtins.str]] = None,
|
|
240
|
+
discovery_ca_pems: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
241
|
+
expiration_leeway: Optional[pulumi.Input[builtins.str]] = None,
|
|
242
|
+
jwks_ca_cert: Optional[pulumi.Input[builtins.str]] = None,
|
|
243
|
+
jwks_url: Optional[pulumi.Input[builtins.str]] = None,
|
|
244
|
+
jwt_validation_pub_keys: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
245
|
+
list_claim_mappings: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None,
|
|
246
|
+
not_before_leeway: Optional[pulumi.Input[builtins.str]] = None,
|
|
247
|
+
oidc_client_assertion: Optional[pulumi.Input['AclAuthMethodConfigOidcClientAssertionArgs']] = None,
|
|
248
|
+
oidc_client_id: Optional[pulumi.Input[builtins.str]] = None,
|
|
249
|
+
oidc_client_secret: Optional[pulumi.Input[builtins.str]] = None,
|
|
250
|
+
oidc_disable_userinfo: Optional[pulumi.Input[builtins.bool]] = None,
|
|
251
|
+
oidc_discovery_url: Optional[pulumi.Input[builtins.str]] = None,
|
|
252
|
+
oidc_enable_pkce: Optional[pulumi.Input[builtins.bool]] = None,
|
|
253
|
+
oidc_scopes: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
254
|
+
signing_algs: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
255
|
+
verbose_logging: Optional[pulumi.Input[builtins.bool]] = None):
|
|
256
|
+
"""
|
|
257
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] allowed_redirect_uris: `([]string: <optional>)` - A list of allowed values
|
|
225
258
|
that can be used for the redirect URI.
|
|
226
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] bound_audiences: `([]string: <optional>)` - List of auth claims that are
|
|
259
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] bound_audiences: `([]string: <optional>)` - List of auth claims that are
|
|
227
260
|
valid for login.
|
|
228
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] bound_issuers: `([]string: <optional>)` - The value against which to match
|
|
261
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] bound_issuers: `([]string: <optional>)` - The value against which to match
|
|
229
262
|
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
|
|
263
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] claim_mappings: Mappings of claims (key) that will be copied to a metadata field (value).
|
|
264
|
+
:param pulumi.Input[builtins.str] clock_skew_leeway: `(string: <optional>)` - Duration of leeway when validating
|
|
232
265
|
all claims in the form of a time duration such as "5m" or "1h".
|
|
233
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] discovery_ca_pems: `([]string: <optional>)` - PEM encoded CA certs for use
|
|
266
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] discovery_ca_pems: `([]string: <optional>)` - PEM encoded CA certs for use
|
|
234
267
|
by the TLS client used to talk with the OIDC Discovery URL.
|
|
235
|
-
:param pulumi.Input[str] expiration_leeway: `(string: <optional>)` - Duration of leeway when validating
|
|
268
|
+
:param pulumi.Input[builtins.str] expiration_leeway: `(string: <optional>)` - Duration of leeway when validating
|
|
236
269
|
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
|
|
270
|
+
:param pulumi.Input[builtins.str] jwks_ca_cert: `(string: <optional>)` - PEM encoded CA cert for use by the
|
|
238
271
|
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
|
|
272
|
+
:param pulumi.Input[builtins.str] jwks_url: `(string: <optional>)` - JSON Web Key Sets url for authenticating
|
|
240
273
|
signatures.
|
|
241
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] jwt_validation_pub_keys: `([]string: <optional>)` - List of PEM-encoded
|
|
274
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] jwt_validation_pub_keys: `([]string: <optional>)` - List of PEM-encoded
|
|
242
275
|
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
|
|
276
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] list_claim_mappings: Mappings of list claims (key) that will be copied to a metadata field (value).
|
|
277
|
+
:param pulumi.Input[builtins.str] not_before_leeway: `(string: <optional>)` - Duration of leeway when validating
|
|
245
278
|
not before values of a token in the form of a time duration such as "5m" or "1h".
|
|
246
|
-
:param pulumi.Input[
|
|
279
|
+
:param pulumi.Input['AclAuthMethodConfigOidcClientAssertionArgs'] oidc_client_assertion: `(OIDCClientAssertion: <optional>)` - Optionally
|
|
280
|
+
send a signed JWT ("[private key jwt][]") as a client assertion to the OIDC
|
|
281
|
+
provider. Browse to the [OIDC concepts][concepts-assertions] page to learn
|
|
282
|
+
more.
|
|
283
|
+
:param pulumi.Input[builtins.str] oidc_client_id: `(string: <optional>)` - The OAuth Client ID configured
|
|
247
284
|
with the OIDC provider.
|
|
248
|
-
:param pulumi.Input[str] oidc_client_secret: `(string: <optional>)` - The OAuth Client Secret
|
|
285
|
+
:param pulumi.Input[builtins.str] oidc_client_secret: `(string: <optional>)` - The OAuth Client Secret
|
|
249
286
|
configured with the OIDC provider.
|
|
250
|
-
:param pulumi.Input[bool] oidc_disable_userinfo: `(bool: false)` - When set to `true`, Nomad will
|
|
287
|
+
:param pulumi.Input[builtins.bool] oidc_disable_userinfo: `(bool: false)` - When set to `true`, Nomad will
|
|
251
288
|
not make a request to the identity provider to get OIDC `UserInfo`.
|
|
252
289
|
You may wish to set this if your identity provider doesn't send any
|
|
253
290
|
additional claims from the `UserInfo` endpoint.
|
|
254
|
-
:param pulumi.Input[str] oidc_discovery_url: `(string: <optional>)` - The OIDC Discovery URL,
|
|
291
|
+
:param pulumi.Input[builtins.str] oidc_discovery_url: `(string: <optional>)` - The OIDC Discovery URL,
|
|
255
292
|
without any .well-known component (base path).
|
|
256
|
-
:param pulumi.Input[
|
|
257
|
-
|
|
293
|
+
:param pulumi.Input[builtins.bool] oidc_enable_pkce: `(bool: false)` - When set to `true`, Nomad will include
|
|
294
|
+
[PKCE][] verification in the auth flow. Even with PKCE enabled in Nomad,
|
|
295
|
+
you may still need to enable it in your OIDC provider.
|
|
296
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] oidc_scopes: `([]string: <optional>)` - List of OIDC scopes.
|
|
297
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] signing_algs: `([]string: <optional>)` - A list of supported signing
|
|
258
298
|
algorithms.
|
|
299
|
+
:param pulumi.Input[builtins.bool] verbose_logging: Enable OIDC verbose logging on the Nomad server.
|
|
259
300
|
"""
|
|
260
301
|
if allowed_redirect_uris is not None:
|
|
261
302
|
pulumi.set(__self__, "allowed_redirect_uris", allowed_redirect_uris)
|
|
@@ -281,6 +322,8 @@ class AclAuthMethodConfigArgs:
|
|
|
281
322
|
pulumi.set(__self__, "list_claim_mappings", list_claim_mappings)
|
|
282
323
|
if not_before_leeway is not None:
|
|
283
324
|
pulumi.set(__self__, "not_before_leeway", not_before_leeway)
|
|
325
|
+
if oidc_client_assertion is not None:
|
|
326
|
+
pulumi.set(__self__, "oidc_client_assertion", oidc_client_assertion)
|
|
284
327
|
if oidc_client_id is not None:
|
|
285
328
|
pulumi.set(__self__, "oidc_client_id", oidc_client_id)
|
|
286
329
|
if oidc_client_secret is not None:
|
|
@@ -289,14 +332,18 @@ class AclAuthMethodConfigArgs:
|
|
|
289
332
|
pulumi.set(__self__, "oidc_disable_userinfo", oidc_disable_userinfo)
|
|
290
333
|
if oidc_discovery_url is not None:
|
|
291
334
|
pulumi.set(__self__, "oidc_discovery_url", oidc_discovery_url)
|
|
335
|
+
if oidc_enable_pkce is not None:
|
|
336
|
+
pulumi.set(__self__, "oidc_enable_pkce", oidc_enable_pkce)
|
|
292
337
|
if oidc_scopes is not None:
|
|
293
338
|
pulumi.set(__self__, "oidc_scopes", oidc_scopes)
|
|
294
339
|
if signing_algs is not None:
|
|
295
340
|
pulumi.set(__self__, "signing_algs", signing_algs)
|
|
341
|
+
if verbose_logging is not None:
|
|
342
|
+
pulumi.set(__self__, "verbose_logging", verbose_logging)
|
|
296
343
|
|
|
297
344
|
@property
|
|
298
345
|
@pulumi.getter(name="allowedRedirectUris")
|
|
299
|
-
def allowed_redirect_uris(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
346
|
+
def allowed_redirect_uris(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
300
347
|
"""
|
|
301
348
|
`([]string: <optional>)` - A list of allowed values
|
|
302
349
|
that can be used for the redirect URI.
|
|
@@ -304,12 +351,12 @@ class AclAuthMethodConfigArgs:
|
|
|
304
351
|
return pulumi.get(self, "allowed_redirect_uris")
|
|
305
352
|
|
|
306
353
|
@allowed_redirect_uris.setter
|
|
307
|
-
def allowed_redirect_uris(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
354
|
+
def allowed_redirect_uris(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
308
355
|
pulumi.set(self, "allowed_redirect_uris", value)
|
|
309
356
|
|
|
310
357
|
@property
|
|
311
358
|
@pulumi.getter(name="boundAudiences")
|
|
312
|
-
def bound_audiences(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
359
|
+
def bound_audiences(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
313
360
|
"""
|
|
314
361
|
`([]string: <optional>)` - List of auth claims that are
|
|
315
362
|
valid for login.
|
|
@@ -317,12 +364,12 @@ class AclAuthMethodConfigArgs:
|
|
|
317
364
|
return pulumi.get(self, "bound_audiences")
|
|
318
365
|
|
|
319
366
|
@bound_audiences.setter
|
|
320
|
-
def bound_audiences(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
367
|
+
def bound_audiences(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
321
368
|
pulumi.set(self, "bound_audiences", value)
|
|
322
369
|
|
|
323
370
|
@property
|
|
324
371
|
@pulumi.getter(name="boundIssuers")
|
|
325
|
-
def bound_issuers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
372
|
+
def bound_issuers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
326
373
|
"""
|
|
327
374
|
`([]string: <optional>)` - The value against which to match
|
|
328
375
|
the iss claim in a JWT.
|
|
@@ -330,24 +377,24 @@ class AclAuthMethodConfigArgs:
|
|
|
330
377
|
return pulumi.get(self, "bound_issuers")
|
|
331
378
|
|
|
332
379
|
@bound_issuers.setter
|
|
333
|
-
def bound_issuers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
380
|
+
def bound_issuers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
334
381
|
pulumi.set(self, "bound_issuers", value)
|
|
335
382
|
|
|
336
383
|
@property
|
|
337
384
|
@pulumi.getter(name="claimMappings")
|
|
338
|
-
def claim_mappings(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
385
|
+
def claim_mappings(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]:
|
|
339
386
|
"""
|
|
340
387
|
Mappings of claims (key) that will be copied to a metadata field (value).
|
|
341
388
|
"""
|
|
342
389
|
return pulumi.get(self, "claim_mappings")
|
|
343
390
|
|
|
344
391
|
@claim_mappings.setter
|
|
345
|
-
def claim_mappings(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
392
|
+
def claim_mappings(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]):
|
|
346
393
|
pulumi.set(self, "claim_mappings", value)
|
|
347
394
|
|
|
348
395
|
@property
|
|
349
396
|
@pulumi.getter(name="clockSkewLeeway")
|
|
350
|
-
def clock_skew_leeway(self) -> Optional[pulumi.Input[str]]:
|
|
397
|
+
def clock_skew_leeway(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
351
398
|
"""
|
|
352
399
|
`(string: <optional>)` - Duration of leeway when validating
|
|
353
400
|
all claims in the form of a time duration such as "5m" or "1h".
|
|
@@ -355,12 +402,12 @@ class AclAuthMethodConfigArgs:
|
|
|
355
402
|
return pulumi.get(self, "clock_skew_leeway")
|
|
356
403
|
|
|
357
404
|
@clock_skew_leeway.setter
|
|
358
|
-
def clock_skew_leeway(self, value: Optional[pulumi.Input[str]]):
|
|
405
|
+
def clock_skew_leeway(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
359
406
|
pulumi.set(self, "clock_skew_leeway", value)
|
|
360
407
|
|
|
361
408
|
@property
|
|
362
409
|
@pulumi.getter(name="discoveryCaPems")
|
|
363
|
-
def discovery_ca_pems(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
410
|
+
def discovery_ca_pems(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
364
411
|
"""
|
|
365
412
|
`([]string: <optional>)` - PEM encoded CA certs for use
|
|
366
413
|
by the TLS client used to talk with the OIDC Discovery URL.
|
|
@@ -368,12 +415,12 @@ class AclAuthMethodConfigArgs:
|
|
|
368
415
|
return pulumi.get(self, "discovery_ca_pems")
|
|
369
416
|
|
|
370
417
|
@discovery_ca_pems.setter
|
|
371
|
-
def discovery_ca_pems(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
418
|
+
def discovery_ca_pems(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
372
419
|
pulumi.set(self, "discovery_ca_pems", value)
|
|
373
420
|
|
|
374
421
|
@property
|
|
375
422
|
@pulumi.getter(name="expirationLeeway")
|
|
376
|
-
def expiration_leeway(self) -> Optional[pulumi.Input[str]]:
|
|
423
|
+
def expiration_leeway(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
377
424
|
"""
|
|
378
425
|
`(string: <optional>)` - Duration of leeway when validating
|
|
379
426
|
expiration of a JWT in the form of a time duration such as "5m" or "1h".
|
|
@@ -381,12 +428,12 @@ class AclAuthMethodConfigArgs:
|
|
|
381
428
|
return pulumi.get(self, "expiration_leeway")
|
|
382
429
|
|
|
383
430
|
@expiration_leeway.setter
|
|
384
|
-
def expiration_leeway(self, value: Optional[pulumi.Input[str]]):
|
|
431
|
+
def expiration_leeway(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
385
432
|
pulumi.set(self, "expiration_leeway", value)
|
|
386
433
|
|
|
387
434
|
@property
|
|
388
435
|
@pulumi.getter(name="jwksCaCert")
|
|
389
|
-
def jwks_ca_cert(self) -> Optional[pulumi.Input[str]]:
|
|
436
|
+
def jwks_ca_cert(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
390
437
|
"""
|
|
391
438
|
`(string: <optional>)` - PEM encoded CA cert for use by the
|
|
392
439
|
TLS client used to talk with the JWKS server.
|
|
@@ -394,12 +441,12 @@ class AclAuthMethodConfigArgs:
|
|
|
394
441
|
return pulumi.get(self, "jwks_ca_cert")
|
|
395
442
|
|
|
396
443
|
@jwks_ca_cert.setter
|
|
397
|
-
def jwks_ca_cert(self, value: Optional[pulumi.Input[str]]):
|
|
444
|
+
def jwks_ca_cert(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
398
445
|
pulumi.set(self, "jwks_ca_cert", value)
|
|
399
446
|
|
|
400
447
|
@property
|
|
401
448
|
@pulumi.getter(name="jwksUrl")
|
|
402
|
-
def jwks_url(self) -> Optional[pulumi.Input[str]]:
|
|
449
|
+
def jwks_url(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
403
450
|
"""
|
|
404
451
|
`(string: <optional>)` - JSON Web Key Sets url for authenticating
|
|
405
452
|
signatures.
|
|
@@ -407,12 +454,12 @@ class AclAuthMethodConfigArgs:
|
|
|
407
454
|
return pulumi.get(self, "jwks_url")
|
|
408
455
|
|
|
409
456
|
@jwks_url.setter
|
|
410
|
-
def jwks_url(self, value: Optional[pulumi.Input[str]]):
|
|
457
|
+
def jwks_url(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
411
458
|
pulumi.set(self, "jwks_url", value)
|
|
412
459
|
|
|
413
460
|
@property
|
|
414
461
|
@pulumi.getter(name="jwtValidationPubKeys")
|
|
415
|
-
def jwt_validation_pub_keys(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
462
|
+
def jwt_validation_pub_keys(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
416
463
|
"""
|
|
417
464
|
`([]string: <optional>)` - List of PEM-encoded
|
|
418
465
|
public keys to use to authenticate signatures locally.
|
|
@@ -420,24 +467,24 @@ class AclAuthMethodConfigArgs:
|
|
|
420
467
|
return pulumi.get(self, "jwt_validation_pub_keys")
|
|
421
468
|
|
|
422
469
|
@jwt_validation_pub_keys.setter
|
|
423
|
-
def jwt_validation_pub_keys(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
470
|
+
def jwt_validation_pub_keys(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
424
471
|
pulumi.set(self, "jwt_validation_pub_keys", value)
|
|
425
472
|
|
|
426
473
|
@property
|
|
427
474
|
@pulumi.getter(name="listClaimMappings")
|
|
428
|
-
def list_claim_mappings(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
475
|
+
def list_claim_mappings(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]:
|
|
429
476
|
"""
|
|
430
477
|
Mappings of list claims (key) that will be copied to a metadata field (value).
|
|
431
478
|
"""
|
|
432
479
|
return pulumi.get(self, "list_claim_mappings")
|
|
433
480
|
|
|
434
481
|
@list_claim_mappings.setter
|
|
435
|
-
def list_claim_mappings(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
482
|
+
def list_claim_mappings(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]):
|
|
436
483
|
pulumi.set(self, "list_claim_mappings", value)
|
|
437
484
|
|
|
438
485
|
@property
|
|
439
486
|
@pulumi.getter(name="notBeforeLeeway")
|
|
440
|
-
def not_before_leeway(self) -> Optional[pulumi.Input[str]]:
|
|
487
|
+
def not_before_leeway(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
441
488
|
"""
|
|
442
489
|
`(string: <optional>)` - Duration of leeway when validating
|
|
443
490
|
not before values of a token in the form of a time duration such as "5m" or "1h".
|
|
@@ -445,12 +492,27 @@ class AclAuthMethodConfigArgs:
|
|
|
445
492
|
return pulumi.get(self, "not_before_leeway")
|
|
446
493
|
|
|
447
494
|
@not_before_leeway.setter
|
|
448
|
-
def not_before_leeway(self, value: Optional[pulumi.Input[str]]):
|
|
495
|
+
def not_before_leeway(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
449
496
|
pulumi.set(self, "not_before_leeway", value)
|
|
450
497
|
|
|
498
|
+
@property
|
|
499
|
+
@pulumi.getter(name="oidcClientAssertion")
|
|
500
|
+
def oidc_client_assertion(self) -> Optional[pulumi.Input['AclAuthMethodConfigOidcClientAssertionArgs']]:
|
|
501
|
+
"""
|
|
502
|
+
`(OIDCClientAssertion: <optional>)` - Optionally
|
|
503
|
+
send a signed JWT ("[private key jwt][]") as a client assertion to the OIDC
|
|
504
|
+
provider. Browse to the [OIDC concepts][concepts-assertions] page to learn
|
|
505
|
+
more.
|
|
506
|
+
"""
|
|
507
|
+
return pulumi.get(self, "oidc_client_assertion")
|
|
508
|
+
|
|
509
|
+
@oidc_client_assertion.setter
|
|
510
|
+
def oidc_client_assertion(self, value: Optional[pulumi.Input['AclAuthMethodConfigOidcClientAssertionArgs']]):
|
|
511
|
+
pulumi.set(self, "oidc_client_assertion", value)
|
|
512
|
+
|
|
451
513
|
@property
|
|
452
514
|
@pulumi.getter(name="oidcClientId")
|
|
453
|
-
def oidc_client_id(self) -> Optional[pulumi.Input[str]]:
|
|
515
|
+
def oidc_client_id(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
454
516
|
"""
|
|
455
517
|
`(string: <optional>)` - The OAuth Client ID configured
|
|
456
518
|
with the OIDC provider.
|
|
@@ -458,12 +520,12 @@ class AclAuthMethodConfigArgs:
|
|
|
458
520
|
return pulumi.get(self, "oidc_client_id")
|
|
459
521
|
|
|
460
522
|
@oidc_client_id.setter
|
|
461
|
-
def oidc_client_id(self, value: Optional[pulumi.Input[str]]):
|
|
523
|
+
def oidc_client_id(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
462
524
|
pulumi.set(self, "oidc_client_id", value)
|
|
463
525
|
|
|
464
526
|
@property
|
|
465
527
|
@pulumi.getter(name="oidcClientSecret")
|
|
466
|
-
def oidc_client_secret(self) -> Optional[pulumi.Input[str]]:
|
|
528
|
+
def oidc_client_secret(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
467
529
|
"""
|
|
468
530
|
`(string: <optional>)` - The OAuth Client Secret
|
|
469
531
|
configured with the OIDC provider.
|
|
@@ -471,12 +533,12 @@ class AclAuthMethodConfigArgs:
|
|
|
471
533
|
return pulumi.get(self, "oidc_client_secret")
|
|
472
534
|
|
|
473
535
|
@oidc_client_secret.setter
|
|
474
|
-
def oidc_client_secret(self, value: Optional[pulumi.Input[str]]):
|
|
536
|
+
def oidc_client_secret(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
475
537
|
pulumi.set(self, "oidc_client_secret", value)
|
|
476
538
|
|
|
477
539
|
@property
|
|
478
540
|
@pulumi.getter(name="oidcDisableUserinfo")
|
|
479
|
-
def oidc_disable_userinfo(self) -> Optional[pulumi.Input[bool]]:
|
|
541
|
+
def oidc_disable_userinfo(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
480
542
|
"""
|
|
481
543
|
`(bool: false)` - When set to `true`, Nomad will
|
|
482
544
|
not make a request to the identity provider to get OIDC `UserInfo`.
|
|
@@ -486,12 +548,12 @@ class AclAuthMethodConfigArgs:
|
|
|
486
548
|
return pulumi.get(self, "oidc_disable_userinfo")
|
|
487
549
|
|
|
488
550
|
@oidc_disable_userinfo.setter
|
|
489
|
-
def oidc_disable_userinfo(self, value: Optional[pulumi.Input[bool]]):
|
|
551
|
+
def oidc_disable_userinfo(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
490
552
|
pulumi.set(self, "oidc_disable_userinfo", value)
|
|
491
553
|
|
|
492
554
|
@property
|
|
493
555
|
@pulumi.getter(name="oidcDiscoveryUrl")
|
|
494
|
-
def oidc_discovery_url(self) -> Optional[pulumi.Input[str]]:
|
|
556
|
+
def oidc_discovery_url(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
495
557
|
"""
|
|
496
558
|
`(string: <optional>)` - The OIDC Discovery URL,
|
|
497
559
|
without any .well-known component (base path).
|
|
@@ -499,24 +561,38 @@ class AclAuthMethodConfigArgs:
|
|
|
499
561
|
return pulumi.get(self, "oidc_discovery_url")
|
|
500
562
|
|
|
501
563
|
@oidc_discovery_url.setter
|
|
502
|
-
def oidc_discovery_url(self, value: Optional[pulumi.Input[str]]):
|
|
564
|
+
def oidc_discovery_url(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
503
565
|
pulumi.set(self, "oidc_discovery_url", value)
|
|
504
566
|
|
|
567
|
+
@property
|
|
568
|
+
@pulumi.getter(name="oidcEnablePkce")
|
|
569
|
+
def oidc_enable_pkce(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
570
|
+
"""
|
|
571
|
+
`(bool: false)` - When set to `true`, Nomad will include
|
|
572
|
+
[PKCE][] verification in the auth flow. Even with PKCE enabled in Nomad,
|
|
573
|
+
you may still need to enable it in your OIDC provider.
|
|
574
|
+
"""
|
|
575
|
+
return pulumi.get(self, "oidc_enable_pkce")
|
|
576
|
+
|
|
577
|
+
@oidc_enable_pkce.setter
|
|
578
|
+
def oidc_enable_pkce(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
579
|
+
pulumi.set(self, "oidc_enable_pkce", value)
|
|
580
|
+
|
|
505
581
|
@property
|
|
506
582
|
@pulumi.getter(name="oidcScopes")
|
|
507
|
-
def oidc_scopes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
583
|
+
def oidc_scopes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
508
584
|
"""
|
|
509
585
|
`([]string: <optional>)` - List of OIDC scopes.
|
|
510
586
|
"""
|
|
511
587
|
return pulumi.get(self, "oidc_scopes")
|
|
512
588
|
|
|
513
589
|
@oidc_scopes.setter
|
|
514
|
-
def oidc_scopes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
590
|
+
def oidc_scopes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
515
591
|
pulumi.set(self, "oidc_scopes", value)
|
|
516
592
|
|
|
517
593
|
@property
|
|
518
594
|
@pulumi.getter(name="signingAlgs")
|
|
519
|
-
def signing_algs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
595
|
+
def signing_algs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
520
596
|
"""
|
|
521
597
|
`([]string: <optional>)` - A list of supported signing
|
|
522
598
|
algorithms.
|
|
@@ -524,25 +600,373 @@ class AclAuthMethodConfigArgs:
|
|
|
524
600
|
return pulumi.get(self, "signing_algs")
|
|
525
601
|
|
|
526
602
|
@signing_algs.setter
|
|
527
|
-
def signing_algs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
603
|
+
def signing_algs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
528
604
|
pulumi.set(self, "signing_algs", value)
|
|
529
605
|
|
|
606
|
+
@property
|
|
607
|
+
@pulumi.getter(name="verboseLogging")
|
|
608
|
+
def verbose_logging(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
609
|
+
"""
|
|
610
|
+
Enable OIDC verbose logging on the Nomad server.
|
|
611
|
+
"""
|
|
612
|
+
return pulumi.get(self, "verbose_logging")
|
|
613
|
+
|
|
614
|
+
@verbose_logging.setter
|
|
615
|
+
def verbose_logging(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
616
|
+
pulumi.set(self, "verbose_logging", value)
|
|
617
|
+
|
|
618
|
+
|
|
619
|
+
if not MYPY:
|
|
620
|
+
class AclAuthMethodConfigOidcClientAssertionArgsDict(TypedDict):
|
|
621
|
+
key_source: pulumi.Input[builtins.str]
|
|
622
|
+
"""
|
|
623
|
+
`(string: <required>)` - Specifies where to get the private
|
|
624
|
+
key to sign the JWT.
|
|
625
|
+
Available sources:
|
|
626
|
+
- "nomad": Use current active key in Nomad's keyring
|
|
627
|
+
- "private_key": Use key material in the `private_key` field
|
|
628
|
+
- "client_secret": Use the `oidc_client_secret` as an HMAC key
|
|
629
|
+
"""
|
|
630
|
+
audiences: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
|
|
631
|
+
"""
|
|
632
|
+
`([]string: optional)` - Who processes the assertion.
|
|
633
|
+
Defaults to the auth method's `oidc_discovery_url`.
|
|
634
|
+
"""
|
|
635
|
+
extra_headers: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]
|
|
636
|
+
"""
|
|
637
|
+
`(map[string]string: optional)` - Add to the JWT headers,
|
|
638
|
+
alongside "kid" and "type". Setting the "kid" header here is not allowed;
|
|
639
|
+
use `private_key.key_id`.
|
|
640
|
+
"""
|
|
641
|
+
key_algorithm: NotRequired[pulumi.Input[builtins.str]]
|
|
642
|
+
"""
|
|
643
|
+
`(string: <optional>)` is the key's algorithm.
|
|
644
|
+
Its default values are based on the `key_source`:
|
|
645
|
+
- "nomad": "RS256"; this is from Nomad's keyring and must not be changed
|
|
646
|
+
- "private_key": "RS256"; must be RS256, RS384, or RS512
|
|
647
|
+
- "client_secret": "HS256"; must be HS256, HS384, or HS512
|
|
648
|
+
"""
|
|
649
|
+
private_key: NotRequired[pulumi.Input['AclAuthMethodConfigOidcClientAssertionPrivateKeyArgsDict']]
|
|
650
|
+
"""
|
|
651
|
+
`(OIDCClientAssertionKey: <optional>)` - External key
|
|
652
|
+
to sign the JWT. `key_source` must be "private_key" to enable this.
|
|
653
|
+
"""
|
|
654
|
+
elif False:
|
|
655
|
+
AclAuthMethodConfigOidcClientAssertionArgsDict: TypeAlias = Mapping[str, Any]
|
|
656
|
+
|
|
657
|
+
@pulumi.input_type
|
|
658
|
+
class AclAuthMethodConfigOidcClientAssertionArgs:
|
|
659
|
+
def __init__(__self__, *,
|
|
660
|
+
key_source: pulumi.Input[builtins.str],
|
|
661
|
+
audiences: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
662
|
+
extra_headers: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None,
|
|
663
|
+
key_algorithm: Optional[pulumi.Input[builtins.str]] = None,
|
|
664
|
+
private_key: Optional[pulumi.Input['AclAuthMethodConfigOidcClientAssertionPrivateKeyArgs']] = None):
|
|
665
|
+
"""
|
|
666
|
+
:param pulumi.Input[builtins.str] key_source: `(string: <required>)` - Specifies where to get the private
|
|
667
|
+
key to sign the JWT.
|
|
668
|
+
Available sources:
|
|
669
|
+
- "nomad": Use current active key in Nomad's keyring
|
|
670
|
+
- "private_key": Use key material in the `private_key` field
|
|
671
|
+
- "client_secret": Use the `oidc_client_secret` as an HMAC key
|
|
672
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] audiences: `([]string: optional)` - Who processes the assertion.
|
|
673
|
+
Defaults to the auth method's `oidc_discovery_url`.
|
|
674
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] extra_headers: `(map[string]string: optional)` - Add to the JWT headers,
|
|
675
|
+
alongside "kid" and "type". Setting the "kid" header here is not allowed;
|
|
676
|
+
use `private_key.key_id`.
|
|
677
|
+
:param pulumi.Input[builtins.str] key_algorithm: `(string: <optional>)` is the key's algorithm.
|
|
678
|
+
Its default values are based on the `key_source`:
|
|
679
|
+
- "nomad": "RS256"; this is from Nomad's keyring and must not be changed
|
|
680
|
+
- "private_key": "RS256"; must be RS256, RS384, or RS512
|
|
681
|
+
- "client_secret": "HS256"; must be HS256, HS384, or HS512
|
|
682
|
+
:param pulumi.Input['AclAuthMethodConfigOidcClientAssertionPrivateKeyArgs'] private_key: `(OIDCClientAssertionKey: <optional>)` - External key
|
|
683
|
+
to sign the JWT. `key_source` must be "private_key" to enable this.
|
|
684
|
+
"""
|
|
685
|
+
pulumi.set(__self__, "key_source", key_source)
|
|
686
|
+
if audiences is not None:
|
|
687
|
+
pulumi.set(__self__, "audiences", audiences)
|
|
688
|
+
if extra_headers is not None:
|
|
689
|
+
pulumi.set(__self__, "extra_headers", extra_headers)
|
|
690
|
+
if key_algorithm is not None:
|
|
691
|
+
pulumi.set(__self__, "key_algorithm", key_algorithm)
|
|
692
|
+
if private_key is not None:
|
|
693
|
+
pulumi.set(__self__, "private_key", private_key)
|
|
694
|
+
|
|
695
|
+
@property
|
|
696
|
+
@pulumi.getter(name="keySource")
|
|
697
|
+
def key_source(self) -> pulumi.Input[builtins.str]:
|
|
698
|
+
"""
|
|
699
|
+
`(string: <required>)` - Specifies where to get the private
|
|
700
|
+
key to sign the JWT.
|
|
701
|
+
Available sources:
|
|
702
|
+
- "nomad": Use current active key in Nomad's keyring
|
|
703
|
+
- "private_key": Use key material in the `private_key` field
|
|
704
|
+
- "client_secret": Use the `oidc_client_secret` as an HMAC key
|
|
705
|
+
"""
|
|
706
|
+
return pulumi.get(self, "key_source")
|
|
707
|
+
|
|
708
|
+
@key_source.setter
|
|
709
|
+
def key_source(self, value: pulumi.Input[builtins.str]):
|
|
710
|
+
pulumi.set(self, "key_source", value)
|
|
711
|
+
|
|
712
|
+
@property
|
|
713
|
+
@pulumi.getter
|
|
714
|
+
def audiences(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
715
|
+
"""
|
|
716
|
+
`([]string: optional)` - Who processes the assertion.
|
|
717
|
+
Defaults to the auth method's `oidc_discovery_url`.
|
|
718
|
+
"""
|
|
719
|
+
return pulumi.get(self, "audiences")
|
|
720
|
+
|
|
721
|
+
@audiences.setter
|
|
722
|
+
def audiences(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
723
|
+
pulumi.set(self, "audiences", value)
|
|
724
|
+
|
|
725
|
+
@property
|
|
726
|
+
@pulumi.getter(name="extraHeaders")
|
|
727
|
+
def extra_headers(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]:
|
|
728
|
+
"""
|
|
729
|
+
`(map[string]string: optional)` - Add to the JWT headers,
|
|
730
|
+
alongside "kid" and "type". Setting the "kid" header here is not allowed;
|
|
731
|
+
use `private_key.key_id`.
|
|
732
|
+
"""
|
|
733
|
+
return pulumi.get(self, "extra_headers")
|
|
734
|
+
|
|
735
|
+
@extra_headers.setter
|
|
736
|
+
def extra_headers(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]):
|
|
737
|
+
pulumi.set(self, "extra_headers", value)
|
|
738
|
+
|
|
739
|
+
@property
|
|
740
|
+
@pulumi.getter(name="keyAlgorithm")
|
|
741
|
+
def key_algorithm(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
742
|
+
"""
|
|
743
|
+
`(string: <optional>)` is the key's algorithm.
|
|
744
|
+
Its default values are based on the `key_source`:
|
|
745
|
+
- "nomad": "RS256"; this is from Nomad's keyring and must not be changed
|
|
746
|
+
- "private_key": "RS256"; must be RS256, RS384, or RS512
|
|
747
|
+
- "client_secret": "HS256"; must be HS256, HS384, or HS512
|
|
748
|
+
"""
|
|
749
|
+
return pulumi.get(self, "key_algorithm")
|
|
750
|
+
|
|
751
|
+
@key_algorithm.setter
|
|
752
|
+
def key_algorithm(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
753
|
+
pulumi.set(self, "key_algorithm", value)
|
|
754
|
+
|
|
755
|
+
@property
|
|
756
|
+
@pulumi.getter(name="privateKey")
|
|
757
|
+
def private_key(self) -> Optional[pulumi.Input['AclAuthMethodConfigOidcClientAssertionPrivateKeyArgs']]:
|
|
758
|
+
"""
|
|
759
|
+
`(OIDCClientAssertionKey: <optional>)` - External key
|
|
760
|
+
to sign the JWT. `key_source` must be "private_key" to enable this.
|
|
761
|
+
"""
|
|
762
|
+
return pulumi.get(self, "private_key")
|
|
763
|
+
|
|
764
|
+
@private_key.setter
|
|
765
|
+
def private_key(self, value: Optional[pulumi.Input['AclAuthMethodConfigOidcClientAssertionPrivateKeyArgs']]):
|
|
766
|
+
pulumi.set(self, "private_key", value)
|
|
767
|
+
|
|
768
|
+
|
|
769
|
+
if not MYPY:
|
|
770
|
+
class AclAuthMethodConfigOidcClientAssertionPrivateKeyArgsDict(TypedDict):
|
|
771
|
+
key_id: NotRequired[pulumi.Input[builtins.str]]
|
|
772
|
+
"""
|
|
773
|
+
`(string: optional)` - Becomes the JWT's "kid" header.
|
|
774
|
+
Mutually exclusive with `pem_cert` and `pem_cert_file`.
|
|
775
|
+
Allowed `key_id_header` values: "kid" (the default)
|
|
776
|
+
"""
|
|
777
|
+
key_id_header: NotRequired[pulumi.Input[builtins.str]]
|
|
778
|
+
"""
|
|
779
|
+
`(string: optional)` - Which header the provider uses
|
|
780
|
+
to find the public key to verify the signed JWT.
|
|
781
|
+
The default and allowed values depend on whether you set `key_id`,
|
|
782
|
+
`pem_cert`, or `pem_cert_file`. You must set exactly one of those
|
|
783
|
+
options, so refer to them for their requirements.
|
|
784
|
+
"""
|
|
785
|
+
pem_cert: NotRequired[pulumi.Input[builtins.str]]
|
|
786
|
+
"""
|
|
787
|
+
`(string: optional)` - An x509 certificate, signed by the
|
|
788
|
+
private key or a CA, in pem format. Nomad uses this certificate to
|
|
789
|
+
derive an [x5t#S256][] (or [x5t][]) key_id.
|
|
790
|
+
Mutually exclusive with `pem_cert_file` and `key_id`.
|
|
791
|
+
Allowed `key_id_header` values: "x5t", "x5t#S256" (default "x5t#S256")
|
|
792
|
+
"""
|
|
793
|
+
pem_cert_file: NotRequired[pulumi.Input[builtins.str]]
|
|
794
|
+
"""
|
|
795
|
+
`(string: optional)` - An absolute path to an x509
|
|
796
|
+
certificate on Nomad servers' disk, signed by the private key or a CA,
|
|
797
|
+
in pem format.
|
|
798
|
+
Nomad uses this certificate to derive an [x5t#S256][] (or [x5t][])
|
|
799
|
+
header. Mutually exclusive with `pem_cert` and key_id.
|
|
800
|
+
Allowed `key_id_header` values: "x5t", "x5t#S256" (default "x5t#S256")
|
|
801
|
+
"""
|
|
802
|
+
pem_key: NotRequired[pulumi.Input[builtins.str]]
|
|
803
|
+
"""
|
|
804
|
+
`(string: <optional>)` - An RSA private key, in pem format.
|
|
805
|
+
It is used to sign the JWT. Mutually exclusive with `pem_key`.
|
|
806
|
+
"""
|
|
807
|
+
pem_key_file: NotRequired[pulumi.Input[builtins.str]]
|
|
808
|
+
"""
|
|
809
|
+
`(string: optional)` - An absolute path to a private key
|
|
810
|
+
on Nomad servers' disk, in pem format. It is used to sign the JWT.
|
|
811
|
+
Mutually exclusive with `pem_key_file`.
|
|
812
|
+
"""
|
|
813
|
+
elif False:
|
|
814
|
+
AclAuthMethodConfigOidcClientAssertionPrivateKeyArgsDict: TypeAlias = Mapping[str, Any]
|
|
815
|
+
|
|
816
|
+
@pulumi.input_type
|
|
817
|
+
class AclAuthMethodConfigOidcClientAssertionPrivateKeyArgs:
|
|
818
|
+
def __init__(__self__, *,
|
|
819
|
+
key_id: Optional[pulumi.Input[builtins.str]] = None,
|
|
820
|
+
key_id_header: Optional[pulumi.Input[builtins.str]] = None,
|
|
821
|
+
pem_cert: Optional[pulumi.Input[builtins.str]] = None,
|
|
822
|
+
pem_cert_file: Optional[pulumi.Input[builtins.str]] = None,
|
|
823
|
+
pem_key: Optional[pulumi.Input[builtins.str]] = None,
|
|
824
|
+
pem_key_file: Optional[pulumi.Input[builtins.str]] = None):
|
|
825
|
+
"""
|
|
826
|
+
:param pulumi.Input[builtins.str] key_id: `(string: optional)` - Becomes the JWT's "kid" header.
|
|
827
|
+
Mutually exclusive with `pem_cert` and `pem_cert_file`.
|
|
828
|
+
Allowed `key_id_header` values: "kid" (the default)
|
|
829
|
+
:param pulumi.Input[builtins.str] key_id_header: `(string: optional)` - Which header the provider uses
|
|
830
|
+
to find the public key to verify the signed JWT.
|
|
831
|
+
The default and allowed values depend on whether you set `key_id`,
|
|
832
|
+
`pem_cert`, or `pem_cert_file`. You must set exactly one of those
|
|
833
|
+
options, so refer to them for their requirements.
|
|
834
|
+
:param pulumi.Input[builtins.str] pem_cert: `(string: optional)` - An x509 certificate, signed by the
|
|
835
|
+
private key or a CA, in pem format. Nomad uses this certificate to
|
|
836
|
+
derive an [x5t#S256][] (or [x5t][]) key_id.
|
|
837
|
+
Mutually exclusive with `pem_cert_file` and `key_id`.
|
|
838
|
+
Allowed `key_id_header` values: "x5t", "x5t#S256" (default "x5t#S256")
|
|
839
|
+
:param pulumi.Input[builtins.str] pem_cert_file: `(string: optional)` - An absolute path to an x509
|
|
840
|
+
certificate on Nomad servers' disk, signed by the private key or a CA,
|
|
841
|
+
in pem format.
|
|
842
|
+
Nomad uses this certificate to derive an [x5t#S256][] (or [x5t][])
|
|
843
|
+
header. Mutually exclusive with `pem_cert` and key_id.
|
|
844
|
+
Allowed `key_id_header` values: "x5t", "x5t#S256" (default "x5t#S256")
|
|
845
|
+
:param pulumi.Input[builtins.str] pem_key: `(string: <optional>)` - An RSA private key, in pem format.
|
|
846
|
+
It is used to sign the JWT. Mutually exclusive with `pem_key`.
|
|
847
|
+
:param pulumi.Input[builtins.str] pem_key_file: `(string: optional)` - An absolute path to a private key
|
|
848
|
+
on Nomad servers' disk, in pem format. It is used to sign the JWT.
|
|
849
|
+
Mutually exclusive with `pem_key_file`.
|
|
850
|
+
"""
|
|
851
|
+
if key_id is not None:
|
|
852
|
+
pulumi.set(__self__, "key_id", key_id)
|
|
853
|
+
if key_id_header is not None:
|
|
854
|
+
pulumi.set(__self__, "key_id_header", key_id_header)
|
|
855
|
+
if pem_cert is not None:
|
|
856
|
+
pulumi.set(__self__, "pem_cert", pem_cert)
|
|
857
|
+
if pem_cert_file is not None:
|
|
858
|
+
pulumi.set(__self__, "pem_cert_file", pem_cert_file)
|
|
859
|
+
if pem_key is not None:
|
|
860
|
+
pulumi.set(__self__, "pem_key", pem_key)
|
|
861
|
+
if pem_key_file is not None:
|
|
862
|
+
pulumi.set(__self__, "pem_key_file", pem_key_file)
|
|
863
|
+
|
|
864
|
+
@property
|
|
865
|
+
@pulumi.getter(name="keyId")
|
|
866
|
+
def key_id(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
867
|
+
"""
|
|
868
|
+
`(string: optional)` - Becomes the JWT's "kid" header.
|
|
869
|
+
Mutually exclusive with `pem_cert` and `pem_cert_file`.
|
|
870
|
+
Allowed `key_id_header` values: "kid" (the default)
|
|
871
|
+
"""
|
|
872
|
+
return pulumi.get(self, "key_id")
|
|
873
|
+
|
|
874
|
+
@key_id.setter
|
|
875
|
+
def key_id(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
876
|
+
pulumi.set(self, "key_id", value)
|
|
877
|
+
|
|
878
|
+
@property
|
|
879
|
+
@pulumi.getter(name="keyIdHeader")
|
|
880
|
+
def key_id_header(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
881
|
+
"""
|
|
882
|
+
`(string: optional)` - Which header the provider uses
|
|
883
|
+
to find the public key to verify the signed JWT.
|
|
884
|
+
The default and allowed values depend on whether you set `key_id`,
|
|
885
|
+
`pem_cert`, or `pem_cert_file`. You must set exactly one of those
|
|
886
|
+
options, so refer to them for their requirements.
|
|
887
|
+
"""
|
|
888
|
+
return pulumi.get(self, "key_id_header")
|
|
889
|
+
|
|
890
|
+
@key_id_header.setter
|
|
891
|
+
def key_id_header(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
892
|
+
pulumi.set(self, "key_id_header", value)
|
|
893
|
+
|
|
894
|
+
@property
|
|
895
|
+
@pulumi.getter(name="pemCert")
|
|
896
|
+
def pem_cert(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
897
|
+
"""
|
|
898
|
+
`(string: optional)` - An x509 certificate, signed by the
|
|
899
|
+
private key or a CA, in pem format. Nomad uses this certificate to
|
|
900
|
+
derive an [x5t#S256][] (or [x5t][]) key_id.
|
|
901
|
+
Mutually exclusive with `pem_cert_file` and `key_id`.
|
|
902
|
+
Allowed `key_id_header` values: "x5t", "x5t#S256" (default "x5t#S256")
|
|
903
|
+
"""
|
|
904
|
+
return pulumi.get(self, "pem_cert")
|
|
905
|
+
|
|
906
|
+
@pem_cert.setter
|
|
907
|
+
def pem_cert(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
908
|
+
pulumi.set(self, "pem_cert", value)
|
|
909
|
+
|
|
910
|
+
@property
|
|
911
|
+
@pulumi.getter(name="pemCertFile")
|
|
912
|
+
def pem_cert_file(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
913
|
+
"""
|
|
914
|
+
`(string: optional)` - An absolute path to an x509
|
|
915
|
+
certificate on Nomad servers' disk, signed by the private key or a CA,
|
|
916
|
+
in pem format.
|
|
917
|
+
Nomad uses this certificate to derive an [x5t#S256][] (or [x5t][])
|
|
918
|
+
header. Mutually exclusive with `pem_cert` and key_id.
|
|
919
|
+
Allowed `key_id_header` values: "x5t", "x5t#S256" (default "x5t#S256")
|
|
920
|
+
"""
|
|
921
|
+
return pulumi.get(self, "pem_cert_file")
|
|
922
|
+
|
|
923
|
+
@pem_cert_file.setter
|
|
924
|
+
def pem_cert_file(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
925
|
+
pulumi.set(self, "pem_cert_file", value)
|
|
926
|
+
|
|
927
|
+
@property
|
|
928
|
+
@pulumi.getter(name="pemKey")
|
|
929
|
+
def pem_key(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
930
|
+
"""
|
|
931
|
+
`(string: <optional>)` - An RSA private key, in pem format.
|
|
932
|
+
It is used to sign the JWT. Mutually exclusive with `pem_key`.
|
|
933
|
+
"""
|
|
934
|
+
return pulumi.get(self, "pem_key")
|
|
935
|
+
|
|
936
|
+
@pem_key.setter
|
|
937
|
+
def pem_key(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
938
|
+
pulumi.set(self, "pem_key", value)
|
|
939
|
+
|
|
940
|
+
@property
|
|
941
|
+
@pulumi.getter(name="pemKeyFile")
|
|
942
|
+
def pem_key_file(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
943
|
+
"""
|
|
944
|
+
`(string: optional)` - An absolute path to a private key
|
|
945
|
+
on Nomad servers' disk, in pem format. It is used to sign the JWT.
|
|
946
|
+
Mutually exclusive with `pem_key_file`.
|
|
947
|
+
"""
|
|
948
|
+
return pulumi.get(self, "pem_key_file")
|
|
949
|
+
|
|
950
|
+
@pem_key_file.setter
|
|
951
|
+
def pem_key_file(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
952
|
+
pulumi.set(self, "pem_key_file", value)
|
|
953
|
+
|
|
530
954
|
|
|
531
955
|
if not MYPY:
|
|
532
956
|
class AclPolicyJobAclArgsDict(TypedDict):
|
|
533
|
-
job_id: pulumi.Input[str]
|
|
957
|
+
job_id: pulumi.Input[builtins.str]
|
|
534
958
|
"""
|
|
535
959
|
Job
|
|
536
960
|
"""
|
|
537
|
-
group: NotRequired[pulumi.Input[str]]
|
|
961
|
+
group: NotRequired[pulumi.Input[builtins.str]]
|
|
538
962
|
"""
|
|
539
963
|
Group
|
|
540
964
|
"""
|
|
541
|
-
namespace: NotRequired[pulumi.Input[str]]
|
|
965
|
+
namespace: NotRequired[pulumi.Input[builtins.str]]
|
|
542
966
|
"""
|
|
543
967
|
Namespace
|
|
544
968
|
"""
|
|
545
|
-
task: NotRequired[pulumi.Input[str]]
|
|
969
|
+
task: NotRequired[pulumi.Input[builtins.str]]
|
|
546
970
|
"""
|
|
547
971
|
Task
|
|
548
972
|
"""
|
|
@@ -552,15 +976,15 @@ elif False:
|
|
|
552
976
|
@pulumi.input_type
|
|
553
977
|
class AclPolicyJobAclArgs:
|
|
554
978
|
def __init__(__self__, *,
|
|
555
|
-
job_id: pulumi.Input[str],
|
|
556
|
-
group: Optional[pulumi.Input[str]] = None,
|
|
557
|
-
namespace: Optional[pulumi.Input[str]] = None,
|
|
558
|
-
task: Optional[pulumi.Input[str]] = None):
|
|
979
|
+
job_id: pulumi.Input[builtins.str],
|
|
980
|
+
group: Optional[pulumi.Input[builtins.str]] = None,
|
|
981
|
+
namespace: Optional[pulumi.Input[builtins.str]] = None,
|
|
982
|
+
task: Optional[pulumi.Input[builtins.str]] = None):
|
|
559
983
|
"""
|
|
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
|
|
984
|
+
:param pulumi.Input[builtins.str] job_id: Job
|
|
985
|
+
:param pulumi.Input[builtins.str] group: Group
|
|
986
|
+
:param pulumi.Input[builtins.str] namespace: Namespace
|
|
987
|
+
:param pulumi.Input[builtins.str] task: Task
|
|
564
988
|
"""
|
|
565
989
|
pulumi.set(__self__, "job_id", job_id)
|
|
566
990
|
if group is not None:
|
|
@@ -572,56 +996,56 @@ class AclPolicyJobAclArgs:
|
|
|
572
996
|
|
|
573
997
|
@property
|
|
574
998
|
@pulumi.getter(name="jobId")
|
|
575
|
-
def job_id(self) -> pulumi.Input[str]:
|
|
999
|
+
def job_id(self) -> pulumi.Input[builtins.str]:
|
|
576
1000
|
"""
|
|
577
1001
|
Job
|
|
578
1002
|
"""
|
|
579
1003
|
return pulumi.get(self, "job_id")
|
|
580
1004
|
|
|
581
1005
|
@job_id.setter
|
|
582
|
-
def job_id(self, value: pulumi.Input[str]):
|
|
1006
|
+
def job_id(self, value: pulumi.Input[builtins.str]):
|
|
583
1007
|
pulumi.set(self, "job_id", value)
|
|
584
1008
|
|
|
585
1009
|
@property
|
|
586
1010
|
@pulumi.getter
|
|
587
|
-
def group(self) -> Optional[pulumi.Input[str]]:
|
|
1011
|
+
def group(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
588
1012
|
"""
|
|
589
1013
|
Group
|
|
590
1014
|
"""
|
|
591
1015
|
return pulumi.get(self, "group")
|
|
592
1016
|
|
|
593
1017
|
@group.setter
|
|
594
|
-
def group(self, value: Optional[pulumi.Input[str]]):
|
|
1018
|
+
def group(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
595
1019
|
pulumi.set(self, "group", value)
|
|
596
1020
|
|
|
597
1021
|
@property
|
|
598
1022
|
@pulumi.getter
|
|
599
|
-
def namespace(self) -> Optional[pulumi.Input[str]]:
|
|
1023
|
+
def namespace(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
600
1024
|
"""
|
|
601
1025
|
Namespace
|
|
602
1026
|
"""
|
|
603
1027
|
return pulumi.get(self, "namespace")
|
|
604
1028
|
|
|
605
1029
|
@namespace.setter
|
|
606
|
-
def namespace(self, value: Optional[pulumi.Input[str]]):
|
|
1030
|
+
def namespace(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
607
1031
|
pulumi.set(self, "namespace", value)
|
|
608
1032
|
|
|
609
1033
|
@property
|
|
610
1034
|
@pulumi.getter
|
|
611
|
-
def task(self) -> Optional[pulumi.Input[str]]:
|
|
1035
|
+
def task(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
612
1036
|
"""
|
|
613
1037
|
Task
|
|
614
1038
|
"""
|
|
615
1039
|
return pulumi.get(self, "task")
|
|
616
1040
|
|
|
617
1041
|
@task.setter
|
|
618
|
-
def task(self, value: Optional[pulumi.Input[str]]):
|
|
1042
|
+
def task(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
619
1043
|
pulumi.set(self, "task", value)
|
|
620
1044
|
|
|
621
1045
|
|
|
622
1046
|
if not MYPY:
|
|
623
1047
|
class AclRolePolicyArgsDict(TypedDict):
|
|
624
|
-
name: pulumi.Input[str]
|
|
1048
|
+
name: pulumi.Input[builtins.str]
|
|
625
1049
|
"""
|
|
626
1050
|
`(string: <required>)` - A human-friendly name for this ACL Role.
|
|
627
1051
|
"""
|
|
@@ -631,32 +1055,32 @@ elif False:
|
|
|
631
1055
|
@pulumi.input_type
|
|
632
1056
|
class AclRolePolicyArgs:
|
|
633
1057
|
def __init__(__self__, *,
|
|
634
|
-
name: pulumi.Input[str]):
|
|
1058
|
+
name: pulumi.Input[builtins.str]):
|
|
635
1059
|
"""
|
|
636
|
-
:param pulumi.Input[str] name: `(string: <required>)` - A human-friendly name for this ACL Role.
|
|
1060
|
+
:param pulumi.Input[builtins.str] name: `(string: <required>)` - A human-friendly name for this ACL Role.
|
|
637
1061
|
"""
|
|
638
1062
|
pulumi.set(__self__, "name", name)
|
|
639
1063
|
|
|
640
1064
|
@property
|
|
641
1065
|
@pulumi.getter
|
|
642
|
-
def name(self) -> pulumi.Input[str]:
|
|
1066
|
+
def name(self) -> pulumi.Input[builtins.str]:
|
|
643
1067
|
"""
|
|
644
1068
|
`(string: <required>)` - A human-friendly name for this ACL Role.
|
|
645
1069
|
"""
|
|
646
1070
|
return pulumi.get(self, "name")
|
|
647
1071
|
|
|
648
1072
|
@name.setter
|
|
649
|
-
def name(self, value: pulumi.Input[str]):
|
|
1073
|
+
def name(self, value: pulumi.Input[builtins.str]):
|
|
650
1074
|
pulumi.set(self, "name", value)
|
|
651
1075
|
|
|
652
1076
|
|
|
653
1077
|
if not MYPY:
|
|
654
1078
|
class AclTokenRoleArgsDict(TypedDict):
|
|
655
|
-
id: pulumi.Input[str]
|
|
1079
|
+
id: pulumi.Input[builtins.str]
|
|
656
1080
|
"""
|
|
657
1081
|
The ID of the ACL role to link.
|
|
658
1082
|
"""
|
|
659
|
-
name: NotRequired[pulumi.Input[str]]
|
|
1083
|
+
name: NotRequired[pulumi.Input[builtins.str]]
|
|
660
1084
|
"""
|
|
661
1085
|
`(string: "")` - A human-friendly name for this token.
|
|
662
1086
|
"""
|
|
@@ -666,11 +1090,11 @@ elif False:
|
|
|
666
1090
|
@pulumi.input_type
|
|
667
1091
|
class AclTokenRoleArgs:
|
|
668
1092
|
def __init__(__self__, *,
|
|
669
|
-
id: pulumi.Input[str],
|
|
670
|
-
name: Optional[pulumi.Input[str]] = None):
|
|
1093
|
+
id: pulumi.Input[builtins.str],
|
|
1094
|
+
name: Optional[pulumi.Input[builtins.str]] = None):
|
|
671
1095
|
"""
|
|
672
|
-
:param pulumi.Input[str] id: The ID of the ACL role to link.
|
|
673
|
-
:param pulumi.Input[str] name: `(string: "")` - A human-friendly name for this token.
|
|
1096
|
+
:param pulumi.Input[builtins.str] id: The ID of the ACL role to link.
|
|
1097
|
+
:param pulumi.Input[builtins.str] name: `(string: "")` - A human-friendly name for this token.
|
|
674
1098
|
"""
|
|
675
1099
|
pulumi.set(__self__, "id", id)
|
|
676
1100
|
if name is not None:
|
|
@@ -678,32 +1102,32 @@ class AclTokenRoleArgs:
|
|
|
678
1102
|
|
|
679
1103
|
@property
|
|
680
1104
|
@pulumi.getter
|
|
681
|
-
def id(self) -> pulumi.Input[str]:
|
|
1105
|
+
def id(self) -> pulumi.Input[builtins.str]:
|
|
682
1106
|
"""
|
|
683
1107
|
The ID of the ACL role to link.
|
|
684
1108
|
"""
|
|
685
1109
|
return pulumi.get(self, "id")
|
|
686
1110
|
|
|
687
1111
|
@id.setter
|
|
688
|
-
def id(self, value: pulumi.Input[str]):
|
|
1112
|
+
def id(self, value: pulumi.Input[builtins.str]):
|
|
689
1113
|
pulumi.set(self, "id", value)
|
|
690
1114
|
|
|
691
1115
|
@property
|
|
692
1116
|
@pulumi.getter
|
|
693
|
-
def name(self) -> Optional[pulumi.Input[str]]:
|
|
1117
|
+
def name(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
694
1118
|
"""
|
|
695
1119
|
`(string: "")` - A human-friendly name for this token.
|
|
696
1120
|
"""
|
|
697
1121
|
return pulumi.get(self, "name")
|
|
698
1122
|
|
|
699
1123
|
@name.setter
|
|
700
|
-
def name(self, value: Optional[pulumi.Input[str]]):
|
|
1124
|
+
def name(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
701
1125
|
pulumi.set(self, "name", value)
|
|
702
1126
|
|
|
703
1127
|
|
|
704
1128
|
if not MYPY:
|
|
705
1129
|
class CsiVolumeCapabilityArgsDict(TypedDict):
|
|
706
|
-
access_mode: pulumi.Input[str]
|
|
1130
|
+
access_mode: pulumi.Input[builtins.str]
|
|
707
1131
|
"""
|
|
708
1132
|
`(string: <required>)` - Defines whether a volume should be available concurrently. Possible values are:
|
|
709
1133
|
- `single-node-reader-only`
|
|
@@ -712,7 +1136,7 @@ if not MYPY:
|
|
|
712
1136
|
- `multi-node-single-writer`
|
|
713
1137
|
- `multi-node-multi-writer`
|
|
714
1138
|
"""
|
|
715
|
-
attachment_mode: pulumi.Input[str]
|
|
1139
|
+
attachment_mode: pulumi.Input[builtins.str]
|
|
716
1140
|
"""
|
|
717
1141
|
`(string: <required>)` - The storage API that will be used by the volume. Possible values are:
|
|
718
1142
|
- `block-device`
|
|
@@ -724,16 +1148,16 @@ elif False:
|
|
|
724
1148
|
@pulumi.input_type
|
|
725
1149
|
class CsiVolumeCapabilityArgs:
|
|
726
1150
|
def __init__(__self__, *,
|
|
727
|
-
access_mode: pulumi.Input[str],
|
|
728
|
-
attachment_mode: pulumi.Input[str]):
|
|
1151
|
+
access_mode: pulumi.Input[builtins.str],
|
|
1152
|
+
attachment_mode: pulumi.Input[builtins.str]):
|
|
729
1153
|
"""
|
|
730
|
-
:param pulumi.Input[str] access_mode: `(string: <required>)` - Defines whether a volume should be available concurrently. Possible values are:
|
|
1154
|
+
:param pulumi.Input[builtins.str] access_mode: `(string: <required>)` - Defines whether a volume should be available concurrently. Possible values are:
|
|
731
1155
|
- `single-node-reader-only`
|
|
732
1156
|
- `single-node-writer`
|
|
733
1157
|
- `multi-node-reader-only`
|
|
734
1158
|
- `multi-node-single-writer`
|
|
735
1159
|
- `multi-node-multi-writer`
|
|
736
|
-
:param pulumi.Input[str] attachment_mode: `(string: <required>)` - The storage API that will be used by the volume. Possible values are:
|
|
1160
|
+
:param pulumi.Input[builtins.str] attachment_mode: `(string: <required>)` - The storage API that will be used by the volume. Possible values are:
|
|
737
1161
|
- `block-device`
|
|
738
1162
|
- `file-system`
|
|
739
1163
|
"""
|
|
@@ -742,7 +1166,7 @@ class CsiVolumeCapabilityArgs:
|
|
|
742
1166
|
|
|
743
1167
|
@property
|
|
744
1168
|
@pulumi.getter(name="accessMode")
|
|
745
|
-
def access_mode(self) -> pulumi.Input[str]:
|
|
1169
|
+
def access_mode(self) -> pulumi.Input[builtins.str]:
|
|
746
1170
|
"""
|
|
747
1171
|
`(string: <required>)` - Defines whether a volume should be available concurrently. Possible values are:
|
|
748
1172
|
- `single-node-reader-only`
|
|
@@ -754,12 +1178,12 @@ class CsiVolumeCapabilityArgs:
|
|
|
754
1178
|
return pulumi.get(self, "access_mode")
|
|
755
1179
|
|
|
756
1180
|
@access_mode.setter
|
|
757
|
-
def access_mode(self, value: pulumi.Input[str]):
|
|
1181
|
+
def access_mode(self, value: pulumi.Input[builtins.str]):
|
|
758
1182
|
pulumi.set(self, "access_mode", value)
|
|
759
1183
|
|
|
760
1184
|
@property
|
|
761
1185
|
@pulumi.getter(name="attachmentMode")
|
|
762
|
-
def attachment_mode(self) -> pulumi.Input[str]:
|
|
1186
|
+
def attachment_mode(self) -> pulumi.Input[builtins.str]:
|
|
763
1187
|
"""
|
|
764
1188
|
`(string: <required>)` - The storage API that will be used by the volume. Possible values are:
|
|
765
1189
|
- `block-device`
|
|
@@ -768,17 +1192,17 @@ class CsiVolumeCapabilityArgs:
|
|
|
768
1192
|
return pulumi.get(self, "attachment_mode")
|
|
769
1193
|
|
|
770
1194
|
@attachment_mode.setter
|
|
771
|
-
def attachment_mode(self, value: pulumi.Input[str]):
|
|
1195
|
+
def attachment_mode(self, value: pulumi.Input[builtins.str]):
|
|
772
1196
|
pulumi.set(self, "attachment_mode", value)
|
|
773
1197
|
|
|
774
1198
|
|
|
775
1199
|
if not MYPY:
|
|
776
1200
|
class CsiVolumeMountOptionsArgsDict(TypedDict):
|
|
777
|
-
fs_type: NotRequired[pulumi.Input[str]]
|
|
1201
|
+
fs_type: NotRequired[pulumi.Input[builtins.str]]
|
|
778
1202
|
"""
|
|
779
1203
|
`(string: optional)` - The file system type.
|
|
780
1204
|
"""
|
|
781
|
-
mount_flags: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
1205
|
+
mount_flags: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
|
|
782
1206
|
"""
|
|
783
1207
|
`[]string: optional` - The flags passed to `mount`.
|
|
784
1208
|
"""
|
|
@@ -788,11 +1212,11 @@ elif False:
|
|
|
788
1212
|
@pulumi.input_type
|
|
789
1213
|
class CsiVolumeMountOptionsArgs:
|
|
790
1214
|
def __init__(__self__, *,
|
|
791
|
-
fs_type: Optional[pulumi.Input[str]] = None,
|
|
792
|
-
mount_flags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
|
|
1215
|
+
fs_type: Optional[pulumi.Input[builtins.str]] = None,
|
|
1216
|
+
mount_flags: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None):
|
|
793
1217
|
"""
|
|
794
|
-
:param pulumi.Input[str] fs_type: `(string: optional)` - The file system type.
|
|
795
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] mount_flags: `[]string: optional` - The flags passed to `mount`.
|
|
1218
|
+
:param pulumi.Input[builtins.str] fs_type: `(string: optional)` - The file system type.
|
|
1219
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] mount_flags: `[]string: optional` - The flags passed to `mount`.
|
|
796
1220
|
"""
|
|
797
1221
|
if fs_type is not None:
|
|
798
1222
|
pulumi.set(__self__, "fs_type", fs_type)
|
|
@@ -801,32 +1225,32 @@ class CsiVolumeMountOptionsArgs:
|
|
|
801
1225
|
|
|
802
1226
|
@property
|
|
803
1227
|
@pulumi.getter(name="fsType")
|
|
804
|
-
def fs_type(self) -> Optional[pulumi.Input[str]]:
|
|
1228
|
+
def fs_type(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
805
1229
|
"""
|
|
806
1230
|
`(string: optional)` - The file system type.
|
|
807
1231
|
"""
|
|
808
1232
|
return pulumi.get(self, "fs_type")
|
|
809
1233
|
|
|
810
1234
|
@fs_type.setter
|
|
811
|
-
def fs_type(self, value: Optional[pulumi.Input[str]]):
|
|
1235
|
+
def fs_type(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
812
1236
|
pulumi.set(self, "fs_type", value)
|
|
813
1237
|
|
|
814
1238
|
@property
|
|
815
1239
|
@pulumi.getter(name="mountFlags")
|
|
816
|
-
def mount_flags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
1240
|
+
def mount_flags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
817
1241
|
"""
|
|
818
1242
|
`[]string: optional` - The flags passed to `mount`.
|
|
819
1243
|
"""
|
|
820
1244
|
return pulumi.get(self, "mount_flags")
|
|
821
1245
|
|
|
822
1246
|
@mount_flags.setter
|
|
823
|
-
def mount_flags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
1247
|
+
def mount_flags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
824
1248
|
pulumi.set(self, "mount_flags", value)
|
|
825
1249
|
|
|
826
1250
|
|
|
827
1251
|
if not MYPY:
|
|
828
1252
|
class CsiVolumeRegistrationCapabilityArgsDict(TypedDict):
|
|
829
|
-
access_mode: pulumi.Input[str]
|
|
1253
|
+
access_mode: pulumi.Input[builtins.str]
|
|
830
1254
|
"""
|
|
831
1255
|
`(string: <required>)` - Defines whether a volume should be available concurrently. Possible values are:
|
|
832
1256
|
- `single-node-reader-only`
|
|
@@ -835,7 +1259,7 @@ if not MYPY:
|
|
|
835
1259
|
- `multi-node-single-writer`
|
|
836
1260
|
- `multi-node-multi-writer`
|
|
837
1261
|
"""
|
|
838
|
-
attachment_mode: pulumi.Input[str]
|
|
1262
|
+
attachment_mode: pulumi.Input[builtins.str]
|
|
839
1263
|
"""
|
|
840
1264
|
`(string: <required>)` - The storage API that will be used by the volume. Possible values are:
|
|
841
1265
|
- `block-device`
|
|
@@ -847,16 +1271,16 @@ elif False:
|
|
|
847
1271
|
@pulumi.input_type
|
|
848
1272
|
class CsiVolumeRegistrationCapabilityArgs:
|
|
849
1273
|
def __init__(__self__, *,
|
|
850
|
-
access_mode: pulumi.Input[str],
|
|
851
|
-
attachment_mode: pulumi.Input[str]):
|
|
1274
|
+
access_mode: pulumi.Input[builtins.str],
|
|
1275
|
+
attachment_mode: pulumi.Input[builtins.str]):
|
|
852
1276
|
"""
|
|
853
|
-
:param pulumi.Input[str] access_mode: `(string: <required>)` - Defines whether a volume should be available concurrently. Possible values are:
|
|
1277
|
+
:param pulumi.Input[builtins.str] access_mode: `(string: <required>)` - Defines whether a volume should be available concurrently. Possible values are:
|
|
854
1278
|
- `single-node-reader-only`
|
|
855
1279
|
- `single-node-writer`
|
|
856
1280
|
- `multi-node-reader-only`
|
|
857
1281
|
- `multi-node-single-writer`
|
|
858
1282
|
- `multi-node-multi-writer`
|
|
859
|
-
:param pulumi.Input[str] attachment_mode: `(string: <required>)` - The storage API that will be used by the volume. Possible values are:
|
|
1283
|
+
:param pulumi.Input[builtins.str] attachment_mode: `(string: <required>)` - The storage API that will be used by the volume. Possible values are:
|
|
860
1284
|
- `block-device`
|
|
861
1285
|
- `file-system`
|
|
862
1286
|
"""
|
|
@@ -865,7 +1289,7 @@ class CsiVolumeRegistrationCapabilityArgs:
|
|
|
865
1289
|
|
|
866
1290
|
@property
|
|
867
1291
|
@pulumi.getter(name="accessMode")
|
|
868
|
-
def access_mode(self) -> pulumi.Input[str]:
|
|
1292
|
+
def access_mode(self) -> pulumi.Input[builtins.str]:
|
|
869
1293
|
"""
|
|
870
1294
|
`(string: <required>)` - Defines whether a volume should be available concurrently. Possible values are:
|
|
871
1295
|
- `single-node-reader-only`
|
|
@@ -877,12 +1301,12 @@ class CsiVolumeRegistrationCapabilityArgs:
|
|
|
877
1301
|
return pulumi.get(self, "access_mode")
|
|
878
1302
|
|
|
879
1303
|
@access_mode.setter
|
|
880
|
-
def access_mode(self, value: pulumi.Input[str]):
|
|
1304
|
+
def access_mode(self, value: pulumi.Input[builtins.str]):
|
|
881
1305
|
pulumi.set(self, "access_mode", value)
|
|
882
1306
|
|
|
883
1307
|
@property
|
|
884
1308
|
@pulumi.getter(name="attachmentMode")
|
|
885
|
-
def attachment_mode(self) -> pulumi.Input[str]:
|
|
1309
|
+
def attachment_mode(self) -> pulumi.Input[builtins.str]:
|
|
886
1310
|
"""
|
|
887
1311
|
`(string: <required>)` - The storage API that will be used by the volume. Possible values are:
|
|
888
1312
|
- `block-device`
|
|
@@ -891,17 +1315,17 @@ class CsiVolumeRegistrationCapabilityArgs:
|
|
|
891
1315
|
return pulumi.get(self, "attachment_mode")
|
|
892
1316
|
|
|
893
1317
|
@attachment_mode.setter
|
|
894
|
-
def attachment_mode(self, value: pulumi.Input[str]):
|
|
1318
|
+
def attachment_mode(self, value: pulumi.Input[builtins.str]):
|
|
895
1319
|
pulumi.set(self, "attachment_mode", value)
|
|
896
1320
|
|
|
897
1321
|
|
|
898
1322
|
if not MYPY:
|
|
899
1323
|
class CsiVolumeRegistrationMountOptionsArgsDict(TypedDict):
|
|
900
|
-
fs_type: NotRequired[pulumi.Input[str]]
|
|
1324
|
+
fs_type: NotRequired[pulumi.Input[builtins.str]]
|
|
901
1325
|
"""
|
|
902
1326
|
`(string: <optional>)` - The file system type.
|
|
903
1327
|
"""
|
|
904
|
-
mount_flags: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
1328
|
+
mount_flags: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
|
|
905
1329
|
"""
|
|
906
1330
|
`([]string: <optional>)` - The flags passed to `mount`.
|
|
907
1331
|
"""
|
|
@@ -911,11 +1335,11 @@ elif False:
|
|
|
911
1335
|
@pulumi.input_type
|
|
912
1336
|
class CsiVolumeRegistrationMountOptionsArgs:
|
|
913
1337
|
def __init__(__self__, *,
|
|
914
|
-
fs_type: Optional[pulumi.Input[str]] = None,
|
|
915
|
-
mount_flags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
|
|
1338
|
+
fs_type: Optional[pulumi.Input[builtins.str]] = None,
|
|
1339
|
+
mount_flags: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None):
|
|
916
1340
|
"""
|
|
917
|
-
:param pulumi.Input[str] fs_type: `(string: <optional>)` - The file system type.
|
|
918
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] mount_flags: `([]string: <optional>)` - The flags passed to `mount`.
|
|
1341
|
+
:param pulumi.Input[builtins.str] fs_type: `(string: <optional>)` - The file system type.
|
|
1342
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] mount_flags: `([]string: <optional>)` - The flags passed to `mount`.
|
|
919
1343
|
"""
|
|
920
1344
|
if fs_type is not None:
|
|
921
1345
|
pulumi.set(__self__, "fs_type", fs_type)
|
|
@@ -924,32 +1348,32 @@ class CsiVolumeRegistrationMountOptionsArgs:
|
|
|
924
1348
|
|
|
925
1349
|
@property
|
|
926
1350
|
@pulumi.getter(name="fsType")
|
|
927
|
-
def fs_type(self) -> Optional[pulumi.Input[str]]:
|
|
1351
|
+
def fs_type(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
928
1352
|
"""
|
|
929
1353
|
`(string: <optional>)` - The file system type.
|
|
930
1354
|
"""
|
|
931
1355
|
return pulumi.get(self, "fs_type")
|
|
932
1356
|
|
|
933
1357
|
@fs_type.setter
|
|
934
|
-
def fs_type(self, value: Optional[pulumi.Input[str]]):
|
|
1358
|
+
def fs_type(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
935
1359
|
pulumi.set(self, "fs_type", value)
|
|
936
1360
|
|
|
937
1361
|
@property
|
|
938
1362
|
@pulumi.getter(name="mountFlags")
|
|
939
|
-
def mount_flags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
1363
|
+
def mount_flags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
940
1364
|
"""
|
|
941
1365
|
`([]string: <optional>)` - The flags passed to `mount`.
|
|
942
1366
|
"""
|
|
943
1367
|
return pulumi.get(self, "mount_flags")
|
|
944
1368
|
|
|
945
1369
|
@mount_flags.setter
|
|
946
|
-
def mount_flags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
1370
|
+
def mount_flags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
947
1371
|
pulumi.set(self, "mount_flags", value)
|
|
948
1372
|
|
|
949
1373
|
|
|
950
1374
|
if not MYPY:
|
|
951
1375
|
class CsiVolumeRegistrationTopologyArgsDict(TypedDict):
|
|
952
|
-
segments: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
1376
|
+
segments: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]
|
|
953
1377
|
"""
|
|
954
1378
|
`(map[string]string)` - Define the attributes for the topology request.
|
|
955
1379
|
|
|
@@ -962,9 +1386,9 @@ elif False:
|
|
|
962
1386
|
@pulumi.input_type
|
|
963
1387
|
class CsiVolumeRegistrationTopologyArgs:
|
|
964
1388
|
def __init__(__self__, *,
|
|
965
|
-
segments: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None):
|
|
1389
|
+
segments: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None):
|
|
966
1390
|
"""
|
|
967
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] segments: `(map[string]string)` - Define the attributes for the topology request.
|
|
1391
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] segments: `(map[string]string)` - Define the attributes for the topology request.
|
|
968
1392
|
|
|
969
1393
|
In addition to the above arguments, the following attributes are exported and
|
|
970
1394
|
can be referenced:
|
|
@@ -974,7 +1398,7 @@ class CsiVolumeRegistrationTopologyArgs:
|
|
|
974
1398
|
|
|
975
1399
|
@property
|
|
976
1400
|
@pulumi.getter
|
|
977
|
-
def segments(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
1401
|
+
def segments(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]:
|
|
978
1402
|
"""
|
|
979
1403
|
`(map[string]string)` - Define the attributes for the topology request.
|
|
980
1404
|
|
|
@@ -984,7 +1408,7 @@ class CsiVolumeRegistrationTopologyArgs:
|
|
|
984
1408
|
return pulumi.get(self, "segments")
|
|
985
1409
|
|
|
986
1410
|
@segments.setter
|
|
987
|
-
def segments(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
1411
|
+
def segments(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]):
|
|
988
1412
|
pulumi.set(self, "segments", value)
|
|
989
1413
|
|
|
990
1414
|
|
|
@@ -1053,7 +1477,7 @@ class CsiVolumeRegistrationTopologyRequestRequiredArgs:
|
|
|
1053
1477
|
|
|
1054
1478
|
if not MYPY:
|
|
1055
1479
|
class CsiVolumeRegistrationTopologyRequestRequiredTopologyArgsDict(TypedDict):
|
|
1056
|
-
segments: pulumi.Input[Mapping[str, pulumi.Input[str]]]
|
|
1480
|
+
segments: pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]
|
|
1057
1481
|
"""
|
|
1058
1482
|
Define attributes for the topology request.
|
|
1059
1483
|
"""
|
|
@@ -1063,28 +1487,28 @@ elif False:
|
|
|
1063
1487
|
@pulumi.input_type
|
|
1064
1488
|
class CsiVolumeRegistrationTopologyRequestRequiredTopologyArgs:
|
|
1065
1489
|
def __init__(__self__, *,
|
|
1066
|
-
segments: pulumi.Input[Mapping[str, pulumi.Input[str]]]):
|
|
1490
|
+
segments: pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]):
|
|
1067
1491
|
"""
|
|
1068
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] segments: Define attributes for the topology request.
|
|
1492
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] segments: Define attributes for the topology request.
|
|
1069
1493
|
"""
|
|
1070
1494
|
pulumi.set(__self__, "segments", segments)
|
|
1071
1495
|
|
|
1072
1496
|
@property
|
|
1073
1497
|
@pulumi.getter
|
|
1074
|
-
def segments(self) -> pulumi.Input[Mapping[str, pulumi.Input[str]]]:
|
|
1498
|
+
def segments(self) -> pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]:
|
|
1075
1499
|
"""
|
|
1076
1500
|
Define attributes for the topology request.
|
|
1077
1501
|
"""
|
|
1078
1502
|
return pulumi.get(self, "segments")
|
|
1079
1503
|
|
|
1080
1504
|
@segments.setter
|
|
1081
|
-
def segments(self, value: pulumi.Input[Mapping[str, pulumi.Input[str]]]):
|
|
1505
|
+
def segments(self, value: pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]):
|
|
1082
1506
|
pulumi.set(self, "segments", value)
|
|
1083
1507
|
|
|
1084
1508
|
|
|
1085
1509
|
if not MYPY:
|
|
1086
1510
|
class CsiVolumeTopologyArgsDict(TypedDict):
|
|
1087
|
-
segments: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
1511
|
+
segments: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]
|
|
1088
1512
|
"""
|
|
1089
1513
|
`(map[string]string)` - Define the attributes for the topology request.
|
|
1090
1514
|
|
|
@@ -1097,9 +1521,9 @@ elif False:
|
|
|
1097
1521
|
@pulumi.input_type
|
|
1098
1522
|
class CsiVolumeTopologyArgs:
|
|
1099
1523
|
def __init__(__self__, *,
|
|
1100
|
-
segments: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None):
|
|
1524
|
+
segments: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None):
|
|
1101
1525
|
"""
|
|
1102
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] segments: `(map[string]string)` - Define the attributes for the topology request.
|
|
1526
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] segments: `(map[string]string)` - Define the attributes for the topology request.
|
|
1103
1527
|
|
|
1104
1528
|
In addition to the above arguments, the following attributes are exported and
|
|
1105
1529
|
can be referenced:
|
|
@@ -1109,7 +1533,7 @@ class CsiVolumeTopologyArgs:
|
|
|
1109
1533
|
|
|
1110
1534
|
@property
|
|
1111
1535
|
@pulumi.getter
|
|
1112
|
-
def segments(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
1536
|
+
def segments(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]:
|
|
1113
1537
|
"""
|
|
1114
1538
|
`(map[string]string)` - Define the attributes for the topology request.
|
|
1115
1539
|
|
|
@@ -1119,7 +1543,7 @@ class CsiVolumeTopologyArgs:
|
|
|
1119
1543
|
return pulumi.get(self, "segments")
|
|
1120
1544
|
|
|
1121
1545
|
@segments.setter
|
|
1122
|
-
def segments(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
1546
|
+
def segments(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]):
|
|
1123
1547
|
pulumi.set(self, "segments", value)
|
|
1124
1548
|
|
|
1125
1549
|
|
|
@@ -1208,7 +1632,7 @@ class CsiVolumeTopologyRequestPreferredArgs:
|
|
|
1208
1632
|
|
|
1209
1633
|
if not MYPY:
|
|
1210
1634
|
class CsiVolumeTopologyRequestPreferredTopologyArgsDict(TypedDict):
|
|
1211
|
-
segments: pulumi.Input[Mapping[str, pulumi.Input[str]]]
|
|
1635
|
+
segments: pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]
|
|
1212
1636
|
"""
|
|
1213
1637
|
Define the attributes for the topology request.
|
|
1214
1638
|
"""
|
|
@@ -1218,22 +1642,22 @@ elif False:
|
|
|
1218
1642
|
@pulumi.input_type
|
|
1219
1643
|
class CsiVolumeTopologyRequestPreferredTopologyArgs:
|
|
1220
1644
|
def __init__(__self__, *,
|
|
1221
|
-
segments: pulumi.Input[Mapping[str, pulumi.Input[str]]]):
|
|
1645
|
+
segments: pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]):
|
|
1222
1646
|
"""
|
|
1223
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] segments: Define the attributes for the topology request.
|
|
1647
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] segments: Define the attributes for the topology request.
|
|
1224
1648
|
"""
|
|
1225
1649
|
pulumi.set(__self__, "segments", segments)
|
|
1226
1650
|
|
|
1227
1651
|
@property
|
|
1228
1652
|
@pulumi.getter
|
|
1229
|
-
def segments(self) -> pulumi.Input[Mapping[str, pulumi.Input[str]]]:
|
|
1653
|
+
def segments(self) -> pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]:
|
|
1230
1654
|
"""
|
|
1231
1655
|
Define the attributes for the topology request.
|
|
1232
1656
|
"""
|
|
1233
1657
|
return pulumi.get(self, "segments")
|
|
1234
1658
|
|
|
1235
1659
|
@segments.setter
|
|
1236
|
-
def segments(self, value: pulumi.Input[Mapping[str, pulumi.Input[str]]]):
|
|
1660
|
+
def segments(self, value: pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]):
|
|
1237
1661
|
pulumi.set(self, "segments", value)
|
|
1238
1662
|
|
|
1239
1663
|
|
|
@@ -1270,7 +1694,7 @@ class CsiVolumeTopologyRequestRequiredArgs:
|
|
|
1270
1694
|
|
|
1271
1695
|
if not MYPY:
|
|
1272
1696
|
class CsiVolumeTopologyRequestRequiredTopologyArgsDict(TypedDict):
|
|
1273
|
-
segments: pulumi.Input[Mapping[str, pulumi.Input[str]]]
|
|
1697
|
+
segments: pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]
|
|
1274
1698
|
"""
|
|
1275
1699
|
Define the attributes for the topology request.
|
|
1276
1700
|
"""
|
|
@@ -1280,28 +1704,282 @@ elif False:
|
|
|
1280
1704
|
@pulumi.input_type
|
|
1281
1705
|
class CsiVolumeTopologyRequestRequiredTopologyArgs:
|
|
1282
1706
|
def __init__(__self__, *,
|
|
1283
|
-
segments: pulumi.Input[Mapping[str, pulumi.Input[str]]]):
|
|
1707
|
+
segments: pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]):
|
|
1284
1708
|
"""
|
|
1285
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] segments: Define the attributes for the topology request.
|
|
1709
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] segments: Define the attributes for the topology request.
|
|
1286
1710
|
"""
|
|
1287
1711
|
pulumi.set(__self__, "segments", segments)
|
|
1288
1712
|
|
|
1289
1713
|
@property
|
|
1290
1714
|
@pulumi.getter
|
|
1291
|
-
def segments(self) -> pulumi.Input[Mapping[str, pulumi.Input[str]]]:
|
|
1715
|
+
def segments(self) -> pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]:
|
|
1292
1716
|
"""
|
|
1293
1717
|
Define the attributes for the topology request.
|
|
1294
1718
|
"""
|
|
1295
1719
|
return pulumi.get(self, "segments")
|
|
1296
1720
|
|
|
1297
1721
|
@segments.setter
|
|
1298
|
-
def segments(self, value: pulumi.Input[Mapping[str, pulumi.Input[str]]]):
|
|
1722
|
+
def segments(self, value: pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]):
|
|
1299
1723
|
pulumi.set(self, "segments", value)
|
|
1300
1724
|
|
|
1301
1725
|
|
|
1726
|
+
if not MYPY:
|
|
1727
|
+
class DynamicHostVolumeCapabilityArgsDict(TypedDict):
|
|
1728
|
+
access_mode: pulumi.Input[builtins.str]
|
|
1729
|
+
"""
|
|
1730
|
+
`(string)` - How the volume can be mounted by
|
|
1731
|
+
allocations. Refer to the [`access_mode`][] documentation for details.
|
|
1732
|
+
"""
|
|
1733
|
+
attachment_mode: pulumi.Input[builtins.str]
|
|
1734
|
+
"""
|
|
1735
|
+
`(string)` - The storage API that will be used by the
|
|
1736
|
+
volume. Refer to the [`attachment_mode`][] documentation.
|
|
1737
|
+
"""
|
|
1738
|
+
elif False:
|
|
1739
|
+
DynamicHostVolumeCapabilityArgsDict: TypeAlias = Mapping[str, Any]
|
|
1740
|
+
|
|
1741
|
+
@pulumi.input_type
|
|
1742
|
+
class DynamicHostVolumeCapabilityArgs:
|
|
1743
|
+
def __init__(__self__, *,
|
|
1744
|
+
access_mode: pulumi.Input[builtins.str],
|
|
1745
|
+
attachment_mode: pulumi.Input[builtins.str]):
|
|
1746
|
+
"""
|
|
1747
|
+
:param pulumi.Input[builtins.str] access_mode: `(string)` - How the volume can be mounted by
|
|
1748
|
+
allocations. Refer to the [`access_mode`][] documentation for details.
|
|
1749
|
+
:param pulumi.Input[builtins.str] attachment_mode: `(string)` - The storage API that will be used by the
|
|
1750
|
+
volume. Refer to the [`attachment_mode`][] documentation.
|
|
1751
|
+
"""
|
|
1752
|
+
pulumi.set(__self__, "access_mode", access_mode)
|
|
1753
|
+
pulumi.set(__self__, "attachment_mode", attachment_mode)
|
|
1754
|
+
|
|
1755
|
+
@property
|
|
1756
|
+
@pulumi.getter(name="accessMode")
|
|
1757
|
+
def access_mode(self) -> pulumi.Input[builtins.str]:
|
|
1758
|
+
"""
|
|
1759
|
+
`(string)` - How the volume can be mounted by
|
|
1760
|
+
allocations. Refer to the [`access_mode`][] documentation for details.
|
|
1761
|
+
"""
|
|
1762
|
+
return pulumi.get(self, "access_mode")
|
|
1763
|
+
|
|
1764
|
+
@access_mode.setter
|
|
1765
|
+
def access_mode(self, value: pulumi.Input[builtins.str]):
|
|
1766
|
+
pulumi.set(self, "access_mode", value)
|
|
1767
|
+
|
|
1768
|
+
@property
|
|
1769
|
+
@pulumi.getter(name="attachmentMode")
|
|
1770
|
+
def attachment_mode(self) -> pulumi.Input[builtins.str]:
|
|
1771
|
+
"""
|
|
1772
|
+
`(string)` - The storage API that will be used by the
|
|
1773
|
+
volume. Refer to the [`attachment_mode`][] documentation.
|
|
1774
|
+
"""
|
|
1775
|
+
return pulumi.get(self, "attachment_mode")
|
|
1776
|
+
|
|
1777
|
+
@attachment_mode.setter
|
|
1778
|
+
def attachment_mode(self, value: pulumi.Input[builtins.str]):
|
|
1779
|
+
pulumi.set(self, "attachment_mode", value)
|
|
1780
|
+
|
|
1781
|
+
|
|
1782
|
+
if not MYPY:
|
|
1783
|
+
class DynamicHostVolumeConstraintArgsDict(TypedDict):
|
|
1784
|
+
attribute: pulumi.Input[builtins.str]
|
|
1785
|
+
"""
|
|
1786
|
+
`(string)` - The [node attribute][] to check for the constraint.
|
|
1787
|
+
"""
|
|
1788
|
+
operator: NotRequired[pulumi.Input[builtins.str]]
|
|
1789
|
+
"""
|
|
1790
|
+
`(string)`- The operator to use in the comparison.
|
|
1791
|
+
"""
|
|
1792
|
+
value: NotRequired[pulumi.Input[builtins.str]]
|
|
1793
|
+
"""
|
|
1794
|
+
`(string)` - The value of the attribute to compare against.
|
|
1795
|
+
"""
|
|
1796
|
+
elif False:
|
|
1797
|
+
DynamicHostVolumeConstraintArgsDict: TypeAlias = Mapping[str, Any]
|
|
1798
|
+
|
|
1799
|
+
@pulumi.input_type
|
|
1800
|
+
class DynamicHostVolumeConstraintArgs:
|
|
1801
|
+
def __init__(__self__, *,
|
|
1802
|
+
attribute: pulumi.Input[builtins.str],
|
|
1803
|
+
operator: Optional[pulumi.Input[builtins.str]] = None,
|
|
1804
|
+
value: Optional[pulumi.Input[builtins.str]] = None):
|
|
1805
|
+
"""
|
|
1806
|
+
:param pulumi.Input[builtins.str] attribute: `(string)` - The [node attribute][] to check for the constraint.
|
|
1807
|
+
:param pulumi.Input[builtins.str] operator: `(string)`- The operator to use in the comparison.
|
|
1808
|
+
:param pulumi.Input[builtins.str] value: `(string)` - The value of the attribute to compare against.
|
|
1809
|
+
"""
|
|
1810
|
+
pulumi.set(__self__, "attribute", attribute)
|
|
1811
|
+
if operator is not None:
|
|
1812
|
+
pulumi.set(__self__, "operator", operator)
|
|
1813
|
+
if value is not None:
|
|
1814
|
+
pulumi.set(__self__, "value", value)
|
|
1815
|
+
|
|
1816
|
+
@property
|
|
1817
|
+
@pulumi.getter
|
|
1818
|
+
def attribute(self) -> pulumi.Input[builtins.str]:
|
|
1819
|
+
"""
|
|
1820
|
+
`(string)` - The [node attribute][] to check for the constraint.
|
|
1821
|
+
"""
|
|
1822
|
+
return pulumi.get(self, "attribute")
|
|
1823
|
+
|
|
1824
|
+
@attribute.setter
|
|
1825
|
+
def attribute(self, value: pulumi.Input[builtins.str]):
|
|
1826
|
+
pulumi.set(self, "attribute", value)
|
|
1827
|
+
|
|
1828
|
+
@property
|
|
1829
|
+
@pulumi.getter
|
|
1830
|
+
def operator(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
1831
|
+
"""
|
|
1832
|
+
`(string)`- The operator to use in the comparison.
|
|
1833
|
+
"""
|
|
1834
|
+
return pulumi.get(self, "operator")
|
|
1835
|
+
|
|
1836
|
+
@operator.setter
|
|
1837
|
+
def operator(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
1838
|
+
pulumi.set(self, "operator", value)
|
|
1839
|
+
|
|
1840
|
+
@property
|
|
1841
|
+
@pulumi.getter
|
|
1842
|
+
def value(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
1843
|
+
"""
|
|
1844
|
+
`(string)` - The value of the attribute to compare against.
|
|
1845
|
+
"""
|
|
1846
|
+
return pulumi.get(self, "value")
|
|
1847
|
+
|
|
1848
|
+
@value.setter
|
|
1849
|
+
def value(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
1850
|
+
pulumi.set(self, "value", value)
|
|
1851
|
+
|
|
1852
|
+
|
|
1853
|
+
if not MYPY:
|
|
1854
|
+
class DynamicHostVolumeRegistrationCapabilityArgsDict(TypedDict):
|
|
1855
|
+
access_mode: pulumi.Input[builtins.str]
|
|
1856
|
+
"""
|
|
1857
|
+
`(string)` - How the volume can be mounted by
|
|
1858
|
+
allocations. Refer to the [`access_mode`][] documentation for details.
|
|
1859
|
+
"""
|
|
1860
|
+
attachment_mode: pulumi.Input[builtins.str]
|
|
1861
|
+
"""
|
|
1862
|
+
`(string)` - The storage API that will be used by the
|
|
1863
|
+
volume. Refer to the [`attachment_mode`][] documentation.
|
|
1864
|
+
"""
|
|
1865
|
+
elif False:
|
|
1866
|
+
DynamicHostVolumeRegistrationCapabilityArgsDict: TypeAlias = Mapping[str, Any]
|
|
1867
|
+
|
|
1868
|
+
@pulumi.input_type
|
|
1869
|
+
class DynamicHostVolumeRegistrationCapabilityArgs:
|
|
1870
|
+
def __init__(__self__, *,
|
|
1871
|
+
access_mode: pulumi.Input[builtins.str],
|
|
1872
|
+
attachment_mode: pulumi.Input[builtins.str]):
|
|
1873
|
+
"""
|
|
1874
|
+
:param pulumi.Input[builtins.str] access_mode: `(string)` - How the volume can be mounted by
|
|
1875
|
+
allocations. Refer to the [`access_mode`][] documentation for details.
|
|
1876
|
+
:param pulumi.Input[builtins.str] attachment_mode: `(string)` - The storage API that will be used by the
|
|
1877
|
+
volume. Refer to the [`attachment_mode`][] documentation.
|
|
1878
|
+
"""
|
|
1879
|
+
pulumi.set(__self__, "access_mode", access_mode)
|
|
1880
|
+
pulumi.set(__self__, "attachment_mode", attachment_mode)
|
|
1881
|
+
|
|
1882
|
+
@property
|
|
1883
|
+
@pulumi.getter(name="accessMode")
|
|
1884
|
+
def access_mode(self) -> pulumi.Input[builtins.str]:
|
|
1885
|
+
"""
|
|
1886
|
+
`(string)` - How the volume can be mounted by
|
|
1887
|
+
allocations. Refer to the [`access_mode`][] documentation for details.
|
|
1888
|
+
"""
|
|
1889
|
+
return pulumi.get(self, "access_mode")
|
|
1890
|
+
|
|
1891
|
+
@access_mode.setter
|
|
1892
|
+
def access_mode(self, value: pulumi.Input[builtins.str]):
|
|
1893
|
+
pulumi.set(self, "access_mode", value)
|
|
1894
|
+
|
|
1895
|
+
@property
|
|
1896
|
+
@pulumi.getter(name="attachmentMode")
|
|
1897
|
+
def attachment_mode(self) -> pulumi.Input[builtins.str]:
|
|
1898
|
+
"""
|
|
1899
|
+
`(string)` - The storage API that will be used by the
|
|
1900
|
+
volume. Refer to the [`attachment_mode`][] documentation.
|
|
1901
|
+
"""
|
|
1902
|
+
return pulumi.get(self, "attachment_mode")
|
|
1903
|
+
|
|
1904
|
+
@attachment_mode.setter
|
|
1905
|
+
def attachment_mode(self, value: pulumi.Input[builtins.str]):
|
|
1906
|
+
pulumi.set(self, "attachment_mode", value)
|
|
1907
|
+
|
|
1908
|
+
|
|
1909
|
+
if not MYPY:
|
|
1910
|
+
class DynamicHostVolumeRegistrationConstraintArgsDict(TypedDict):
|
|
1911
|
+
attribute: pulumi.Input[builtins.str]
|
|
1912
|
+
"""
|
|
1913
|
+
An attribute to check to constrain volume placement
|
|
1914
|
+
"""
|
|
1915
|
+
operator: NotRequired[pulumi.Input[builtins.str]]
|
|
1916
|
+
"""
|
|
1917
|
+
The operator to use for comparison
|
|
1918
|
+
"""
|
|
1919
|
+
value: NotRequired[pulumi.Input[builtins.str]]
|
|
1920
|
+
"""
|
|
1921
|
+
The requested value of the attribute
|
|
1922
|
+
"""
|
|
1923
|
+
elif False:
|
|
1924
|
+
DynamicHostVolumeRegistrationConstraintArgsDict: TypeAlias = Mapping[str, Any]
|
|
1925
|
+
|
|
1926
|
+
@pulumi.input_type
|
|
1927
|
+
class DynamicHostVolumeRegistrationConstraintArgs:
|
|
1928
|
+
def __init__(__self__, *,
|
|
1929
|
+
attribute: pulumi.Input[builtins.str],
|
|
1930
|
+
operator: Optional[pulumi.Input[builtins.str]] = None,
|
|
1931
|
+
value: Optional[pulumi.Input[builtins.str]] = None):
|
|
1932
|
+
"""
|
|
1933
|
+
:param pulumi.Input[builtins.str] attribute: An attribute to check to constrain volume placement
|
|
1934
|
+
:param pulumi.Input[builtins.str] operator: The operator to use for comparison
|
|
1935
|
+
:param pulumi.Input[builtins.str] value: The requested value of the attribute
|
|
1936
|
+
"""
|
|
1937
|
+
pulumi.set(__self__, "attribute", attribute)
|
|
1938
|
+
if operator is not None:
|
|
1939
|
+
pulumi.set(__self__, "operator", operator)
|
|
1940
|
+
if value is not None:
|
|
1941
|
+
pulumi.set(__self__, "value", value)
|
|
1942
|
+
|
|
1943
|
+
@property
|
|
1944
|
+
@pulumi.getter
|
|
1945
|
+
def attribute(self) -> pulumi.Input[builtins.str]:
|
|
1946
|
+
"""
|
|
1947
|
+
An attribute to check to constrain volume placement
|
|
1948
|
+
"""
|
|
1949
|
+
return pulumi.get(self, "attribute")
|
|
1950
|
+
|
|
1951
|
+
@attribute.setter
|
|
1952
|
+
def attribute(self, value: pulumi.Input[builtins.str]):
|
|
1953
|
+
pulumi.set(self, "attribute", value)
|
|
1954
|
+
|
|
1955
|
+
@property
|
|
1956
|
+
@pulumi.getter
|
|
1957
|
+
def operator(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
1958
|
+
"""
|
|
1959
|
+
The operator to use for comparison
|
|
1960
|
+
"""
|
|
1961
|
+
return pulumi.get(self, "operator")
|
|
1962
|
+
|
|
1963
|
+
@operator.setter
|
|
1964
|
+
def operator(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
1965
|
+
pulumi.set(self, "operator", value)
|
|
1966
|
+
|
|
1967
|
+
@property
|
|
1968
|
+
@pulumi.getter
|
|
1969
|
+
def value(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
1970
|
+
"""
|
|
1971
|
+
The requested value of the attribute
|
|
1972
|
+
"""
|
|
1973
|
+
return pulumi.get(self, "value")
|
|
1974
|
+
|
|
1975
|
+
@value.setter
|
|
1976
|
+
def value(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
1977
|
+
pulumi.set(self, "value", value)
|
|
1978
|
+
|
|
1979
|
+
|
|
1302
1980
|
if not MYPY:
|
|
1303
1981
|
class ExternalVolumeCapabilityArgsDict(TypedDict):
|
|
1304
|
-
access_mode: pulumi.Input[str]
|
|
1982
|
+
access_mode: pulumi.Input[builtins.str]
|
|
1305
1983
|
"""
|
|
1306
1984
|
`(string: <required>)` - Defines whether a volume should be available concurrently. Possible values are:
|
|
1307
1985
|
- `single-node-reader-only`
|
|
@@ -1310,7 +1988,7 @@ if not MYPY:
|
|
|
1310
1988
|
- `multi-node-single-writer`
|
|
1311
1989
|
- `multi-node-multi-writer`
|
|
1312
1990
|
"""
|
|
1313
|
-
attachment_mode: pulumi.Input[str]
|
|
1991
|
+
attachment_mode: pulumi.Input[builtins.str]
|
|
1314
1992
|
"""
|
|
1315
1993
|
`(string: <required>)` - The storage API that will be used by the volume. Possible values are:
|
|
1316
1994
|
- `block-device`
|
|
@@ -1322,16 +2000,16 @@ elif False:
|
|
|
1322
2000
|
@pulumi.input_type
|
|
1323
2001
|
class ExternalVolumeCapabilityArgs:
|
|
1324
2002
|
def __init__(__self__, *,
|
|
1325
|
-
access_mode: pulumi.Input[str],
|
|
1326
|
-
attachment_mode: pulumi.Input[str]):
|
|
2003
|
+
access_mode: pulumi.Input[builtins.str],
|
|
2004
|
+
attachment_mode: pulumi.Input[builtins.str]):
|
|
1327
2005
|
"""
|
|
1328
|
-
:param pulumi.Input[str] access_mode: `(string: <required>)` - Defines whether a volume should be available concurrently. Possible values are:
|
|
2006
|
+
:param pulumi.Input[builtins.str] access_mode: `(string: <required>)` - Defines whether a volume should be available concurrently. Possible values are:
|
|
1329
2007
|
- `single-node-reader-only`
|
|
1330
2008
|
- `single-node-writer`
|
|
1331
2009
|
- `multi-node-reader-only`
|
|
1332
2010
|
- `multi-node-single-writer`
|
|
1333
2011
|
- `multi-node-multi-writer`
|
|
1334
|
-
:param pulumi.Input[str] attachment_mode: `(string: <required>)` - The storage API that will be used by the volume. Possible values are:
|
|
2012
|
+
:param pulumi.Input[builtins.str] attachment_mode: `(string: <required>)` - The storage API that will be used by the volume. Possible values are:
|
|
1335
2013
|
- `block-device`
|
|
1336
2014
|
- `file-system`
|
|
1337
2015
|
"""
|
|
@@ -1340,7 +2018,7 @@ class ExternalVolumeCapabilityArgs:
|
|
|
1340
2018
|
|
|
1341
2019
|
@property
|
|
1342
2020
|
@pulumi.getter(name="accessMode")
|
|
1343
|
-
def access_mode(self) -> pulumi.Input[str]:
|
|
2021
|
+
def access_mode(self) -> pulumi.Input[builtins.str]:
|
|
1344
2022
|
"""
|
|
1345
2023
|
`(string: <required>)` - Defines whether a volume should be available concurrently. Possible values are:
|
|
1346
2024
|
- `single-node-reader-only`
|
|
@@ -1352,12 +2030,12 @@ class ExternalVolumeCapabilityArgs:
|
|
|
1352
2030
|
return pulumi.get(self, "access_mode")
|
|
1353
2031
|
|
|
1354
2032
|
@access_mode.setter
|
|
1355
|
-
def access_mode(self, value: pulumi.Input[str]):
|
|
2033
|
+
def access_mode(self, value: pulumi.Input[builtins.str]):
|
|
1356
2034
|
pulumi.set(self, "access_mode", value)
|
|
1357
2035
|
|
|
1358
2036
|
@property
|
|
1359
2037
|
@pulumi.getter(name="attachmentMode")
|
|
1360
|
-
def attachment_mode(self) -> pulumi.Input[str]:
|
|
2038
|
+
def attachment_mode(self) -> pulumi.Input[builtins.str]:
|
|
1361
2039
|
"""
|
|
1362
2040
|
`(string: <required>)` - The storage API that will be used by the volume. Possible values are:
|
|
1363
2041
|
- `block-device`
|
|
@@ -1366,17 +2044,17 @@ class ExternalVolumeCapabilityArgs:
|
|
|
1366
2044
|
return pulumi.get(self, "attachment_mode")
|
|
1367
2045
|
|
|
1368
2046
|
@attachment_mode.setter
|
|
1369
|
-
def attachment_mode(self, value: pulumi.Input[str]):
|
|
2047
|
+
def attachment_mode(self, value: pulumi.Input[builtins.str]):
|
|
1370
2048
|
pulumi.set(self, "attachment_mode", value)
|
|
1371
2049
|
|
|
1372
2050
|
|
|
1373
2051
|
if not MYPY:
|
|
1374
2052
|
class ExternalVolumeMountOptionsArgsDict(TypedDict):
|
|
1375
|
-
fs_type: NotRequired[pulumi.Input[str]]
|
|
2053
|
+
fs_type: NotRequired[pulumi.Input[builtins.str]]
|
|
1376
2054
|
"""
|
|
1377
2055
|
`(string: optional)` - The file system type.
|
|
1378
2056
|
"""
|
|
1379
|
-
mount_flags: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
2057
|
+
mount_flags: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
|
|
1380
2058
|
"""
|
|
1381
2059
|
`[]string: optional` - The flags passed to `mount`.
|
|
1382
2060
|
"""
|
|
@@ -1386,11 +2064,11 @@ elif False:
|
|
|
1386
2064
|
@pulumi.input_type
|
|
1387
2065
|
class ExternalVolumeMountOptionsArgs:
|
|
1388
2066
|
def __init__(__self__, *,
|
|
1389
|
-
fs_type: Optional[pulumi.Input[str]] = None,
|
|
1390
|
-
mount_flags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
|
|
2067
|
+
fs_type: Optional[pulumi.Input[builtins.str]] = None,
|
|
2068
|
+
mount_flags: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None):
|
|
1391
2069
|
"""
|
|
1392
|
-
:param pulumi.Input[str] fs_type: `(string: optional)` - The file system type.
|
|
1393
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] mount_flags: `[]string: optional` - The flags passed to `mount`.
|
|
2070
|
+
:param pulumi.Input[builtins.str] fs_type: `(string: optional)` - The file system type.
|
|
2071
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] mount_flags: `[]string: optional` - The flags passed to `mount`.
|
|
1394
2072
|
"""
|
|
1395
2073
|
if fs_type is not None:
|
|
1396
2074
|
pulumi.set(__self__, "fs_type", fs_type)
|
|
@@ -1399,32 +2077,32 @@ class ExternalVolumeMountOptionsArgs:
|
|
|
1399
2077
|
|
|
1400
2078
|
@property
|
|
1401
2079
|
@pulumi.getter(name="fsType")
|
|
1402
|
-
def fs_type(self) -> Optional[pulumi.Input[str]]:
|
|
2080
|
+
def fs_type(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
1403
2081
|
"""
|
|
1404
2082
|
`(string: optional)` - The file system type.
|
|
1405
2083
|
"""
|
|
1406
2084
|
return pulumi.get(self, "fs_type")
|
|
1407
2085
|
|
|
1408
2086
|
@fs_type.setter
|
|
1409
|
-
def fs_type(self, value: Optional[pulumi.Input[str]]):
|
|
2087
|
+
def fs_type(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
1410
2088
|
pulumi.set(self, "fs_type", value)
|
|
1411
2089
|
|
|
1412
2090
|
@property
|
|
1413
2091
|
@pulumi.getter(name="mountFlags")
|
|
1414
|
-
def mount_flags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
2092
|
+
def mount_flags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
1415
2093
|
"""
|
|
1416
2094
|
`[]string: optional` - The flags passed to `mount`.
|
|
1417
2095
|
"""
|
|
1418
2096
|
return pulumi.get(self, "mount_flags")
|
|
1419
2097
|
|
|
1420
2098
|
@mount_flags.setter
|
|
1421
|
-
def mount_flags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
2099
|
+
def mount_flags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
1422
2100
|
pulumi.set(self, "mount_flags", value)
|
|
1423
2101
|
|
|
1424
2102
|
|
|
1425
2103
|
if not MYPY:
|
|
1426
2104
|
class ExternalVolumeTopologyArgsDict(TypedDict):
|
|
1427
|
-
segments: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
2105
|
+
segments: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]
|
|
1428
2106
|
"""
|
|
1429
2107
|
`(map[string]string)` - Define the attributes for the topology request.
|
|
1430
2108
|
|
|
@@ -1437,9 +2115,9 @@ elif False:
|
|
|
1437
2115
|
@pulumi.input_type
|
|
1438
2116
|
class ExternalVolumeTopologyArgs:
|
|
1439
2117
|
def __init__(__self__, *,
|
|
1440
|
-
segments: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None):
|
|
2118
|
+
segments: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None):
|
|
1441
2119
|
"""
|
|
1442
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] segments: `(map[string]string)` - Define the attributes for the topology request.
|
|
2120
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] segments: `(map[string]string)` - Define the attributes for the topology request.
|
|
1443
2121
|
|
|
1444
2122
|
In addition to the above arguments, the following attributes are exported and
|
|
1445
2123
|
can be referenced:
|
|
@@ -1449,7 +2127,7 @@ class ExternalVolumeTopologyArgs:
|
|
|
1449
2127
|
|
|
1450
2128
|
@property
|
|
1451
2129
|
@pulumi.getter
|
|
1452
|
-
def segments(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
2130
|
+
def segments(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]:
|
|
1453
2131
|
"""
|
|
1454
2132
|
`(map[string]string)` - Define the attributes for the topology request.
|
|
1455
2133
|
|
|
@@ -1459,7 +2137,7 @@ class ExternalVolumeTopologyArgs:
|
|
|
1459
2137
|
return pulumi.get(self, "segments")
|
|
1460
2138
|
|
|
1461
2139
|
@segments.setter
|
|
1462
|
-
def segments(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
2140
|
+
def segments(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]):
|
|
1463
2141
|
pulumi.set(self, "segments", value)
|
|
1464
2142
|
|
|
1465
2143
|
|
|
@@ -1548,7 +2226,7 @@ class ExternalVolumeTopologyRequestPreferredArgs:
|
|
|
1548
2226
|
|
|
1549
2227
|
if not MYPY:
|
|
1550
2228
|
class ExternalVolumeTopologyRequestPreferredTopologyArgsDict(TypedDict):
|
|
1551
|
-
segments: pulumi.Input[Mapping[str, pulumi.Input[str]]]
|
|
2229
|
+
segments: pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]
|
|
1552
2230
|
"""
|
|
1553
2231
|
Define the attributes for the topology request.
|
|
1554
2232
|
"""
|
|
@@ -1558,22 +2236,22 @@ elif False:
|
|
|
1558
2236
|
@pulumi.input_type
|
|
1559
2237
|
class ExternalVolumeTopologyRequestPreferredTopologyArgs:
|
|
1560
2238
|
def __init__(__self__, *,
|
|
1561
|
-
segments: pulumi.Input[Mapping[str, pulumi.Input[str]]]):
|
|
2239
|
+
segments: pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]):
|
|
1562
2240
|
"""
|
|
1563
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] segments: Define the attributes for the topology request.
|
|
2241
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] segments: Define the attributes for the topology request.
|
|
1564
2242
|
"""
|
|
1565
2243
|
pulumi.set(__self__, "segments", segments)
|
|
1566
2244
|
|
|
1567
2245
|
@property
|
|
1568
2246
|
@pulumi.getter
|
|
1569
|
-
def segments(self) -> pulumi.Input[Mapping[str, pulumi.Input[str]]]:
|
|
2247
|
+
def segments(self) -> pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]:
|
|
1570
2248
|
"""
|
|
1571
2249
|
Define the attributes for the topology request.
|
|
1572
2250
|
"""
|
|
1573
2251
|
return pulumi.get(self, "segments")
|
|
1574
2252
|
|
|
1575
2253
|
@segments.setter
|
|
1576
|
-
def segments(self, value: pulumi.Input[Mapping[str, pulumi.Input[str]]]):
|
|
2254
|
+
def segments(self, value: pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]):
|
|
1577
2255
|
pulumi.set(self, "segments", value)
|
|
1578
2256
|
|
|
1579
2257
|
|
|
@@ -1610,7 +2288,7 @@ class ExternalVolumeTopologyRequestRequiredArgs:
|
|
|
1610
2288
|
|
|
1611
2289
|
if not MYPY:
|
|
1612
2290
|
class ExternalVolumeTopologyRequestRequiredTopologyArgsDict(TypedDict):
|
|
1613
|
-
segments: pulumi.Input[Mapping[str, pulumi.Input[str]]]
|
|
2291
|
+
segments: pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]
|
|
1614
2292
|
"""
|
|
1615
2293
|
Define the attributes for the topology request.
|
|
1616
2294
|
"""
|
|
@@ -1620,33 +2298,33 @@ elif False:
|
|
|
1620
2298
|
@pulumi.input_type
|
|
1621
2299
|
class ExternalVolumeTopologyRequestRequiredTopologyArgs:
|
|
1622
2300
|
def __init__(__self__, *,
|
|
1623
|
-
segments: pulumi.Input[Mapping[str, pulumi.Input[str]]]):
|
|
2301
|
+
segments: pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]):
|
|
1624
2302
|
"""
|
|
1625
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] segments: Define the attributes for the topology request.
|
|
2303
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] segments: Define the attributes for the topology request.
|
|
1626
2304
|
"""
|
|
1627
2305
|
pulumi.set(__self__, "segments", segments)
|
|
1628
2306
|
|
|
1629
2307
|
@property
|
|
1630
2308
|
@pulumi.getter
|
|
1631
|
-
def segments(self) -> pulumi.Input[Mapping[str, pulumi.Input[str]]]:
|
|
2309
|
+
def segments(self) -> pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]:
|
|
1632
2310
|
"""
|
|
1633
2311
|
Define the attributes for the topology request.
|
|
1634
2312
|
"""
|
|
1635
2313
|
return pulumi.get(self, "segments")
|
|
1636
2314
|
|
|
1637
2315
|
@segments.setter
|
|
1638
|
-
def segments(self, value: pulumi.Input[Mapping[str, pulumi.Input[str]]]):
|
|
2316
|
+
def segments(self, value: pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]):
|
|
1639
2317
|
pulumi.set(self, "segments", value)
|
|
1640
2318
|
|
|
1641
2319
|
|
|
1642
2320
|
if not MYPY:
|
|
1643
2321
|
class JobHcl2ArgsDict(TypedDict):
|
|
1644
|
-
allow_fs: NotRequired[pulumi.Input[bool]]
|
|
2322
|
+
allow_fs: NotRequired[pulumi.Input[builtins.bool]]
|
|
1645
2323
|
"""
|
|
1646
2324
|
`(boolean: false)` - Set this to `true` to be able to use
|
|
1647
2325
|
HCL2 filesystem functions
|
|
1648
2326
|
"""
|
|
1649
|
-
vars: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
2327
|
+
vars: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]
|
|
1650
2328
|
"""
|
|
1651
2329
|
Additional variables to use when templating the job with HCL2
|
|
1652
2330
|
"""
|
|
@@ -1656,12 +2334,12 @@ elif False:
|
|
|
1656
2334
|
@pulumi.input_type
|
|
1657
2335
|
class JobHcl2Args:
|
|
1658
2336
|
def __init__(__self__, *,
|
|
1659
|
-
allow_fs: Optional[pulumi.Input[bool]] = None,
|
|
1660
|
-
vars: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None):
|
|
2337
|
+
allow_fs: Optional[pulumi.Input[builtins.bool]] = None,
|
|
2338
|
+
vars: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None):
|
|
1661
2339
|
"""
|
|
1662
|
-
:param pulumi.Input[bool] allow_fs: `(boolean: false)` - Set this to `true` to be able to use
|
|
2340
|
+
:param pulumi.Input[builtins.bool] allow_fs: `(boolean: false)` - Set this to `true` to be able to use
|
|
1663
2341
|
HCL2 filesystem functions
|
|
1664
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] vars: Additional variables to use when templating the job with HCL2
|
|
2342
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] vars: Additional variables to use when templating the job with HCL2
|
|
1665
2343
|
"""
|
|
1666
2344
|
if allow_fs is not None:
|
|
1667
2345
|
pulumi.set(__self__, "allow_fs", allow_fs)
|
|
@@ -1670,7 +2348,7 @@ class JobHcl2Args:
|
|
|
1670
2348
|
|
|
1671
2349
|
@property
|
|
1672
2350
|
@pulumi.getter(name="allowFs")
|
|
1673
|
-
def allow_fs(self) -> Optional[pulumi.Input[bool]]:
|
|
2351
|
+
def allow_fs(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
1674
2352
|
"""
|
|
1675
2353
|
`(boolean: false)` - Set this to `true` to be able to use
|
|
1676
2354
|
HCL2 filesystem functions
|
|
@@ -1678,27 +2356,27 @@ class JobHcl2Args:
|
|
|
1678
2356
|
return pulumi.get(self, "allow_fs")
|
|
1679
2357
|
|
|
1680
2358
|
@allow_fs.setter
|
|
1681
|
-
def allow_fs(self, value: Optional[pulumi.Input[bool]]):
|
|
2359
|
+
def allow_fs(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
1682
2360
|
pulumi.set(self, "allow_fs", value)
|
|
1683
2361
|
|
|
1684
2362
|
@property
|
|
1685
2363
|
@pulumi.getter
|
|
1686
|
-
def vars(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
2364
|
+
def vars(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]:
|
|
1687
2365
|
"""
|
|
1688
2366
|
Additional variables to use when templating the job with HCL2
|
|
1689
2367
|
"""
|
|
1690
2368
|
return pulumi.get(self, "vars")
|
|
1691
2369
|
|
|
1692
2370
|
@vars.setter
|
|
1693
|
-
def vars(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
2371
|
+
def vars(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]):
|
|
1694
2372
|
pulumi.set(self, "vars", value)
|
|
1695
2373
|
|
|
1696
2374
|
|
|
1697
2375
|
if not MYPY:
|
|
1698
2376
|
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]]
|
|
2377
|
+
count: NotRequired[pulumi.Input[builtins.int]]
|
|
2378
|
+
meta: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]
|
|
2379
|
+
name: NotRequired[pulumi.Input[builtins.str]]
|
|
1702
2380
|
tasks: NotRequired[pulumi.Input[Sequence[pulumi.Input['JobTaskGroupTaskArgsDict']]]]
|
|
1703
2381
|
volumes: NotRequired[pulumi.Input[Sequence[pulumi.Input['JobTaskGroupVolumeArgsDict']]]]
|
|
1704
2382
|
elif False:
|
|
@@ -1707,9 +2385,9 @@ elif False:
|
|
|
1707
2385
|
@pulumi.input_type
|
|
1708
2386
|
class JobTaskGroupArgs:
|
|
1709
2387
|
def __init__(__self__, *,
|
|
1710
|
-
count: Optional[pulumi.Input[int]] = None,
|
|
1711
|
-
meta: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
1712
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
2388
|
+
count: Optional[pulumi.Input[builtins.int]] = None,
|
|
2389
|
+
meta: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None,
|
|
2390
|
+
name: Optional[pulumi.Input[builtins.str]] = None,
|
|
1713
2391
|
tasks: Optional[pulumi.Input[Sequence[pulumi.Input['JobTaskGroupTaskArgs']]]] = None,
|
|
1714
2392
|
volumes: Optional[pulumi.Input[Sequence[pulumi.Input['JobTaskGroupVolumeArgs']]]] = None):
|
|
1715
2393
|
if count is not None:
|
|
@@ -1725,29 +2403,29 @@ class JobTaskGroupArgs:
|
|
|
1725
2403
|
|
|
1726
2404
|
@property
|
|
1727
2405
|
@pulumi.getter
|
|
1728
|
-
def count(self) -> Optional[pulumi.Input[int]]:
|
|
2406
|
+
def count(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
1729
2407
|
return pulumi.get(self, "count")
|
|
1730
2408
|
|
|
1731
2409
|
@count.setter
|
|
1732
|
-
def count(self, value: Optional[pulumi.Input[int]]):
|
|
2410
|
+
def count(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
1733
2411
|
pulumi.set(self, "count", value)
|
|
1734
2412
|
|
|
1735
2413
|
@property
|
|
1736
2414
|
@pulumi.getter
|
|
1737
|
-
def meta(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
2415
|
+
def meta(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]:
|
|
1738
2416
|
return pulumi.get(self, "meta")
|
|
1739
2417
|
|
|
1740
2418
|
@meta.setter
|
|
1741
|
-
def meta(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
2419
|
+
def meta(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]):
|
|
1742
2420
|
pulumi.set(self, "meta", value)
|
|
1743
2421
|
|
|
1744
2422
|
@property
|
|
1745
2423
|
@pulumi.getter
|
|
1746
|
-
def name(self) -> Optional[pulumi.Input[str]]:
|
|
2424
|
+
def name(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
1747
2425
|
return pulumi.get(self, "name")
|
|
1748
2426
|
|
|
1749
2427
|
@name.setter
|
|
1750
|
-
def name(self, value: Optional[pulumi.Input[str]]):
|
|
2428
|
+
def name(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
1751
2429
|
pulumi.set(self, "name", value)
|
|
1752
2430
|
|
|
1753
2431
|
@property
|
|
@@ -1771,9 +2449,9 @@ class JobTaskGroupArgs:
|
|
|
1771
2449
|
|
|
1772
2450
|
if not MYPY:
|
|
1773
2451
|
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]]
|
|
2452
|
+
driver: NotRequired[pulumi.Input[builtins.str]]
|
|
2453
|
+
meta: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]
|
|
2454
|
+
name: NotRequired[pulumi.Input[builtins.str]]
|
|
1777
2455
|
volume_mounts: NotRequired[pulumi.Input[Sequence[pulumi.Input['JobTaskGroupTaskVolumeMountArgsDict']]]]
|
|
1778
2456
|
elif False:
|
|
1779
2457
|
JobTaskGroupTaskArgsDict: TypeAlias = Mapping[str, Any]
|
|
@@ -1781,9 +2459,9 @@ elif False:
|
|
|
1781
2459
|
@pulumi.input_type
|
|
1782
2460
|
class JobTaskGroupTaskArgs:
|
|
1783
2461
|
def __init__(__self__, *,
|
|
1784
|
-
driver: Optional[pulumi.Input[str]] = None,
|
|
1785
|
-
meta: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
1786
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
2462
|
+
driver: Optional[pulumi.Input[builtins.str]] = None,
|
|
2463
|
+
meta: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None,
|
|
2464
|
+
name: Optional[pulumi.Input[builtins.str]] = None,
|
|
1787
2465
|
volume_mounts: Optional[pulumi.Input[Sequence[pulumi.Input['JobTaskGroupTaskVolumeMountArgs']]]] = None):
|
|
1788
2466
|
if driver is not None:
|
|
1789
2467
|
pulumi.set(__self__, "driver", driver)
|
|
@@ -1796,29 +2474,29 @@ class JobTaskGroupTaskArgs:
|
|
|
1796
2474
|
|
|
1797
2475
|
@property
|
|
1798
2476
|
@pulumi.getter
|
|
1799
|
-
def driver(self) -> Optional[pulumi.Input[str]]:
|
|
2477
|
+
def driver(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
1800
2478
|
return pulumi.get(self, "driver")
|
|
1801
2479
|
|
|
1802
2480
|
@driver.setter
|
|
1803
|
-
def driver(self, value: Optional[pulumi.Input[str]]):
|
|
2481
|
+
def driver(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
1804
2482
|
pulumi.set(self, "driver", value)
|
|
1805
2483
|
|
|
1806
2484
|
@property
|
|
1807
2485
|
@pulumi.getter
|
|
1808
|
-
def meta(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
2486
|
+
def meta(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]:
|
|
1809
2487
|
return pulumi.get(self, "meta")
|
|
1810
2488
|
|
|
1811
2489
|
@meta.setter
|
|
1812
|
-
def meta(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
2490
|
+
def meta(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]):
|
|
1813
2491
|
pulumi.set(self, "meta", value)
|
|
1814
2492
|
|
|
1815
2493
|
@property
|
|
1816
2494
|
@pulumi.getter
|
|
1817
|
-
def name(self) -> Optional[pulumi.Input[str]]:
|
|
2495
|
+
def name(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
1818
2496
|
return pulumi.get(self, "name")
|
|
1819
2497
|
|
|
1820
2498
|
@name.setter
|
|
1821
|
-
def name(self, value: Optional[pulumi.Input[str]]):
|
|
2499
|
+
def name(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
1822
2500
|
pulumi.set(self, "name", value)
|
|
1823
2501
|
|
|
1824
2502
|
@property
|
|
@@ -1833,18 +2511,18 @@ class JobTaskGroupTaskArgs:
|
|
|
1833
2511
|
|
|
1834
2512
|
if not MYPY:
|
|
1835
2513
|
class JobTaskGroupTaskVolumeMountArgsDict(TypedDict):
|
|
1836
|
-
destination: NotRequired[pulumi.Input[str]]
|
|
1837
|
-
read_only: NotRequired[pulumi.Input[bool]]
|
|
1838
|
-
volume: NotRequired[pulumi.Input[str]]
|
|
2514
|
+
destination: NotRequired[pulumi.Input[builtins.str]]
|
|
2515
|
+
read_only: NotRequired[pulumi.Input[builtins.bool]]
|
|
2516
|
+
volume: NotRequired[pulumi.Input[builtins.str]]
|
|
1839
2517
|
elif False:
|
|
1840
2518
|
JobTaskGroupTaskVolumeMountArgsDict: TypeAlias = Mapping[str, Any]
|
|
1841
2519
|
|
|
1842
2520
|
@pulumi.input_type
|
|
1843
2521
|
class JobTaskGroupTaskVolumeMountArgs:
|
|
1844
2522
|
def __init__(__self__, *,
|
|
1845
|
-
destination: Optional[pulumi.Input[str]] = None,
|
|
1846
|
-
read_only: Optional[pulumi.Input[bool]] = None,
|
|
1847
|
-
volume: Optional[pulumi.Input[str]] = None):
|
|
2523
|
+
destination: Optional[pulumi.Input[builtins.str]] = None,
|
|
2524
|
+
read_only: Optional[pulumi.Input[builtins.bool]] = None,
|
|
2525
|
+
volume: Optional[pulumi.Input[builtins.str]] = None):
|
|
1848
2526
|
if destination is not None:
|
|
1849
2527
|
pulumi.set(__self__, "destination", destination)
|
|
1850
2528
|
if read_only is not None:
|
|
@@ -1854,48 +2532,48 @@ class JobTaskGroupTaskVolumeMountArgs:
|
|
|
1854
2532
|
|
|
1855
2533
|
@property
|
|
1856
2534
|
@pulumi.getter
|
|
1857
|
-
def destination(self) -> Optional[pulumi.Input[str]]:
|
|
2535
|
+
def destination(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
1858
2536
|
return pulumi.get(self, "destination")
|
|
1859
2537
|
|
|
1860
2538
|
@destination.setter
|
|
1861
|
-
def destination(self, value: Optional[pulumi.Input[str]]):
|
|
2539
|
+
def destination(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
1862
2540
|
pulumi.set(self, "destination", value)
|
|
1863
2541
|
|
|
1864
2542
|
@property
|
|
1865
2543
|
@pulumi.getter(name="readOnly")
|
|
1866
|
-
def read_only(self) -> Optional[pulumi.Input[bool]]:
|
|
2544
|
+
def read_only(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
1867
2545
|
return pulumi.get(self, "read_only")
|
|
1868
2546
|
|
|
1869
2547
|
@read_only.setter
|
|
1870
|
-
def read_only(self, value: Optional[pulumi.Input[bool]]):
|
|
2548
|
+
def read_only(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
1871
2549
|
pulumi.set(self, "read_only", value)
|
|
1872
2550
|
|
|
1873
2551
|
@property
|
|
1874
2552
|
@pulumi.getter
|
|
1875
|
-
def volume(self) -> Optional[pulumi.Input[str]]:
|
|
2553
|
+
def volume(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
1876
2554
|
return pulumi.get(self, "volume")
|
|
1877
2555
|
|
|
1878
2556
|
@volume.setter
|
|
1879
|
-
def volume(self, value: Optional[pulumi.Input[str]]):
|
|
2557
|
+
def volume(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
1880
2558
|
pulumi.set(self, "volume", value)
|
|
1881
2559
|
|
|
1882
2560
|
|
|
1883
2561
|
if not MYPY:
|
|
1884
2562
|
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]]
|
|
2563
|
+
name: NotRequired[pulumi.Input[builtins.str]]
|
|
2564
|
+
read_only: NotRequired[pulumi.Input[builtins.bool]]
|
|
2565
|
+
source: NotRequired[pulumi.Input[builtins.str]]
|
|
2566
|
+
type: NotRequired[pulumi.Input[builtins.str]]
|
|
1889
2567
|
elif False:
|
|
1890
2568
|
JobTaskGroupVolumeArgsDict: TypeAlias = Mapping[str, Any]
|
|
1891
2569
|
|
|
1892
2570
|
@pulumi.input_type
|
|
1893
2571
|
class JobTaskGroupVolumeArgs:
|
|
1894
2572
|
def __init__(__self__, *,
|
|
1895
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
1896
|
-
read_only: Optional[pulumi.Input[bool]] = None,
|
|
1897
|
-
source: Optional[pulumi.Input[str]] = None,
|
|
1898
|
-
type: Optional[pulumi.Input[str]] = None):
|
|
2573
|
+
name: Optional[pulumi.Input[builtins.str]] = None,
|
|
2574
|
+
read_only: Optional[pulumi.Input[builtins.bool]] = None,
|
|
2575
|
+
source: Optional[pulumi.Input[builtins.str]] = None,
|
|
2576
|
+
type: Optional[pulumi.Input[builtins.str]] = None):
|
|
1899
2577
|
if name is not None:
|
|
1900
2578
|
pulumi.set(__self__, "name", name)
|
|
1901
2579
|
if read_only is not None:
|
|
@@ -1907,48 +2585,48 @@ class JobTaskGroupVolumeArgs:
|
|
|
1907
2585
|
|
|
1908
2586
|
@property
|
|
1909
2587
|
@pulumi.getter
|
|
1910
|
-
def name(self) -> Optional[pulumi.Input[str]]:
|
|
2588
|
+
def name(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
1911
2589
|
return pulumi.get(self, "name")
|
|
1912
2590
|
|
|
1913
2591
|
@name.setter
|
|
1914
|
-
def name(self, value: Optional[pulumi.Input[str]]):
|
|
2592
|
+
def name(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
1915
2593
|
pulumi.set(self, "name", value)
|
|
1916
2594
|
|
|
1917
2595
|
@property
|
|
1918
2596
|
@pulumi.getter(name="readOnly")
|
|
1919
|
-
def read_only(self) -> Optional[pulumi.Input[bool]]:
|
|
2597
|
+
def read_only(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
1920
2598
|
return pulumi.get(self, "read_only")
|
|
1921
2599
|
|
|
1922
2600
|
@read_only.setter
|
|
1923
|
-
def read_only(self, value: Optional[pulumi.Input[bool]]):
|
|
2601
|
+
def read_only(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
1924
2602
|
pulumi.set(self, "read_only", value)
|
|
1925
2603
|
|
|
1926
2604
|
@property
|
|
1927
2605
|
@pulumi.getter
|
|
1928
|
-
def source(self) -> Optional[pulumi.Input[str]]:
|
|
2606
|
+
def source(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
1929
2607
|
return pulumi.get(self, "source")
|
|
1930
2608
|
|
|
1931
2609
|
@source.setter
|
|
1932
|
-
def source(self, value: Optional[pulumi.Input[str]]):
|
|
2610
|
+
def source(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
1933
2611
|
pulumi.set(self, "source", value)
|
|
1934
2612
|
|
|
1935
2613
|
@property
|
|
1936
2614
|
@pulumi.getter
|
|
1937
|
-
def type(self) -> Optional[pulumi.Input[str]]:
|
|
2615
|
+
def type(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
1938
2616
|
return pulumi.get(self, "type")
|
|
1939
2617
|
|
|
1940
2618
|
@type.setter
|
|
1941
|
-
def type(self, value: Optional[pulumi.Input[str]]):
|
|
2619
|
+
def type(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
1942
2620
|
pulumi.set(self, "type", value)
|
|
1943
2621
|
|
|
1944
2622
|
|
|
1945
2623
|
if not MYPY:
|
|
1946
2624
|
class NamespaceCapabilitiesArgsDict(TypedDict):
|
|
1947
|
-
disabled_task_drivers: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
2625
|
+
disabled_task_drivers: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
|
|
1948
2626
|
"""
|
|
1949
2627
|
`([]string: <optional>)` - Task drivers disabled for the namespace.
|
|
1950
2628
|
"""
|
|
1951
|
-
enabled_task_drivers: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
2629
|
+
enabled_task_drivers: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
|
|
1952
2630
|
"""
|
|
1953
2631
|
`([]string: <optional>)` - Task drivers enabled for the namespace.
|
|
1954
2632
|
"""
|
|
@@ -1958,11 +2636,11 @@ elif False:
|
|
|
1958
2636
|
@pulumi.input_type
|
|
1959
2637
|
class NamespaceCapabilitiesArgs:
|
|
1960
2638
|
def __init__(__self__, *,
|
|
1961
|
-
disabled_task_drivers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1962
|
-
enabled_task_drivers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
|
|
2639
|
+
disabled_task_drivers: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
2640
|
+
enabled_task_drivers: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None):
|
|
1963
2641
|
"""
|
|
1964
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] disabled_task_drivers: `([]string: <optional>)` - Task drivers disabled for the namespace.
|
|
1965
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] enabled_task_drivers: `([]string: <optional>)` - Task drivers enabled for the namespace.
|
|
2642
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] disabled_task_drivers: `([]string: <optional>)` - Task drivers disabled for the namespace.
|
|
2643
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] enabled_task_drivers: `([]string: <optional>)` - Task drivers enabled for the namespace.
|
|
1966
2644
|
"""
|
|
1967
2645
|
if disabled_task_drivers is not None:
|
|
1968
2646
|
pulumi.set(__self__, "disabled_task_drivers", disabled_task_drivers)
|
|
@@ -1971,40 +2649,40 @@ class NamespaceCapabilitiesArgs:
|
|
|
1971
2649
|
|
|
1972
2650
|
@property
|
|
1973
2651
|
@pulumi.getter(name="disabledTaskDrivers")
|
|
1974
|
-
def disabled_task_drivers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
2652
|
+
def disabled_task_drivers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
1975
2653
|
"""
|
|
1976
2654
|
`([]string: <optional>)` - Task drivers disabled for the namespace.
|
|
1977
2655
|
"""
|
|
1978
2656
|
return pulumi.get(self, "disabled_task_drivers")
|
|
1979
2657
|
|
|
1980
2658
|
@disabled_task_drivers.setter
|
|
1981
|
-
def disabled_task_drivers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
2659
|
+
def disabled_task_drivers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
1982
2660
|
pulumi.set(self, "disabled_task_drivers", value)
|
|
1983
2661
|
|
|
1984
2662
|
@property
|
|
1985
2663
|
@pulumi.getter(name="enabledTaskDrivers")
|
|
1986
|
-
def enabled_task_drivers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
2664
|
+
def enabled_task_drivers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
1987
2665
|
"""
|
|
1988
2666
|
`([]string: <optional>)` - Task drivers enabled for the namespace.
|
|
1989
2667
|
"""
|
|
1990
2668
|
return pulumi.get(self, "enabled_task_drivers")
|
|
1991
2669
|
|
|
1992
2670
|
@enabled_task_drivers.setter
|
|
1993
|
-
def enabled_task_drivers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
2671
|
+
def enabled_task_drivers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
1994
2672
|
pulumi.set(self, "enabled_task_drivers", value)
|
|
1995
2673
|
|
|
1996
2674
|
|
|
1997
2675
|
if not MYPY:
|
|
1998
2676
|
class NamespaceNodePoolConfigArgsDict(TypedDict):
|
|
1999
|
-
alloweds: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
2677
|
+
alloweds: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
|
|
2000
2678
|
"""
|
|
2001
2679
|
`([]string: <optional>)` - The list of node pools that are allowed to be used in this namespace.
|
|
2002
2680
|
"""
|
|
2003
|
-
default: NotRequired[pulumi.Input[str]]
|
|
2681
|
+
default: NotRequired[pulumi.Input[builtins.str]]
|
|
2004
2682
|
"""
|
|
2005
2683
|
`(string: <optional>)` - The default node pool for jobs that don't define one.
|
|
2006
2684
|
"""
|
|
2007
|
-
denieds: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
2685
|
+
denieds: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
|
|
2008
2686
|
"""
|
|
2009
2687
|
`([]string: <optional>)` - The list of node pools that are not allowed to be used in this namespace.
|
|
2010
2688
|
"""
|
|
@@ -2014,13 +2692,13 @@ elif False:
|
|
|
2014
2692
|
@pulumi.input_type
|
|
2015
2693
|
class NamespaceNodePoolConfigArgs:
|
|
2016
2694
|
def __init__(__self__, *,
|
|
2017
|
-
alloweds: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
2018
|
-
default: Optional[pulumi.Input[str]] = None,
|
|
2019
|
-
denieds: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
|
|
2695
|
+
alloweds: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
2696
|
+
default: Optional[pulumi.Input[builtins.str]] = None,
|
|
2697
|
+
denieds: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None):
|
|
2020
2698
|
"""
|
|
2021
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] alloweds: `([]string: <optional>)` - The list of node pools that are allowed to be used in this namespace.
|
|
2022
|
-
:param pulumi.Input[str] default: `(string: <optional>)` - The default node pool for jobs that don't define one.
|
|
2023
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] denieds: `([]string: <optional>)` - The list of node pools that are not allowed to be used in this namespace.
|
|
2699
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] alloweds: `([]string: <optional>)` - The list of node pools that are allowed to be used in this namespace.
|
|
2700
|
+
:param pulumi.Input[builtins.str] default: `(string: <optional>)` - The default node pool for jobs that don't define one.
|
|
2701
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] denieds: `([]string: <optional>)` - The list of node pools that are not allowed to be used in this namespace.
|
|
2024
2702
|
"""
|
|
2025
2703
|
if alloweds is not None:
|
|
2026
2704
|
pulumi.set(__self__, "alloweds", alloweds)
|
|
@@ -2031,44 +2709,44 @@ class NamespaceNodePoolConfigArgs:
|
|
|
2031
2709
|
|
|
2032
2710
|
@property
|
|
2033
2711
|
@pulumi.getter
|
|
2034
|
-
def alloweds(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
2712
|
+
def alloweds(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
2035
2713
|
"""
|
|
2036
2714
|
`([]string: <optional>)` - The list of node pools that are allowed to be used in this namespace.
|
|
2037
2715
|
"""
|
|
2038
2716
|
return pulumi.get(self, "alloweds")
|
|
2039
2717
|
|
|
2040
2718
|
@alloweds.setter
|
|
2041
|
-
def alloweds(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
2719
|
+
def alloweds(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
2042
2720
|
pulumi.set(self, "alloweds", value)
|
|
2043
2721
|
|
|
2044
2722
|
@property
|
|
2045
2723
|
@pulumi.getter
|
|
2046
|
-
def default(self) -> Optional[pulumi.Input[str]]:
|
|
2724
|
+
def default(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
2047
2725
|
"""
|
|
2048
2726
|
`(string: <optional>)` - The default node pool for jobs that don't define one.
|
|
2049
2727
|
"""
|
|
2050
2728
|
return pulumi.get(self, "default")
|
|
2051
2729
|
|
|
2052
2730
|
@default.setter
|
|
2053
|
-
def default(self, value: Optional[pulumi.Input[str]]):
|
|
2731
|
+
def default(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
2054
2732
|
pulumi.set(self, "default", value)
|
|
2055
2733
|
|
|
2056
2734
|
@property
|
|
2057
2735
|
@pulumi.getter
|
|
2058
|
-
def denieds(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
2736
|
+
def denieds(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
2059
2737
|
"""
|
|
2060
2738
|
`([]string: <optional>)` - The list of node pools that are not allowed to be used in this namespace.
|
|
2061
2739
|
"""
|
|
2062
2740
|
return pulumi.get(self, "denieds")
|
|
2063
2741
|
|
|
2064
2742
|
@denieds.setter
|
|
2065
|
-
def denieds(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
2743
|
+
def denieds(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
2066
2744
|
pulumi.set(self, "denieds", value)
|
|
2067
2745
|
|
|
2068
2746
|
|
|
2069
2747
|
if not MYPY:
|
|
2070
2748
|
class NodePoolSchedulerConfigArgsDict(TypedDict):
|
|
2071
|
-
memory_oversubscription: NotRequired[pulumi.Input[str]]
|
|
2749
|
+
memory_oversubscription: NotRequired[pulumi.Input[builtins.str]]
|
|
2072
2750
|
"""
|
|
2073
2751
|
`(string)` - Whether or not memory
|
|
2074
2752
|
oversubscription is enabled in the node pool. Possible values are
|
|
@@ -2079,7 +2757,7 @@ if not MYPY:
|
|
|
2079
2757
|
allow distinguishing between memory oversubscription being disabled in the
|
|
2080
2758
|
node pool and this property not being set.
|
|
2081
2759
|
"""
|
|
2082
|
-
scheduler_algorithm: NotRequired[pulumi.Input[str]]
|
|
2760
|
+
scheduler_algorithm: NotRequired[pulumi.Input[builtins.str]]
|
|
2083
2761
|
"""
|
|
2084
2762
|
`(string)` - The scheduler algorithm used in the node
|
|
2085
2763
|
pool. Possible values are `binpack` or `spread`. If not defined the global
|
|
@@ -2091,10 +2769,10 @@ elif False:
|
|
|
2091
2769
|
@pulumi.input_type
|
|
2092
2770
|
class NodePoolSchedulerConfigArgs:
|
|
2093
2771
|
def __init__(__self__, *,
|
|
2094
|
-
memory_oversubscription: Optional[pulumi.Input[str]] = None,
|
|
2095
|
-
scheduler_algorithm: Optional[pulumi.Input[str]] = None):
|
|
2772
|
+
memory_oversubscription: Optional[pulumi.Input[builtins.str]] = None,
|
|
2773
|
+
scheduler_algorithm: Optional[pulumi.Input[builtins.str]] = None):
|
|
2096
2774
|
"""
|
|
2097
|
-
:param pulumi.Input[str] memory_oversubscription: `(string)` - Whether or not memory
|
|
2775
|
+
:param pulumi.Input[builtins.str] memory_oversubscription: `(string)` - Whether or not memory
|
|
2098
2776
|
oversubscription is enabled in the node pool. Possible values are
|
|
2099
2777
|
`"enabled"` or `"disabled"`. If not defined the global cluster
|
|
2100
2778
|
configuration is used.
|
|
@@ -2102,7 +2780,7 @@ class NodePoolSchedulerConfigArgs:
|
|
|
2102
2780
|
> This option differs from Nomad, where it's represented as a boolean, to
|
|
2103
2781
|
allow distinguishing between memory oversubscription being disabled in the
|
|
2104
2782
|
node pool and this property not being set.
|
|
2105
|
-
:param pulumi.Input[str] scheduler_algorithm: `(string)` - The scheduler algorithm used in the node
|
|
2783
|
+
:param pulumi.Input[builtins.str] scheduler_algorithm: `(string)` - The scheduler algorithm used in the node
|
|
2106
2784
|
pool. Possible values are `binpack` or `spread`. If not defined the global
|
|
2107
2785
|
cluster configuration is used.
|
|
2108
2786
|
"""
|
|
@@ -2113,7 +2791,7 @@ class NodePoolSchedulerConfigArgs:
|
|
|
2113
2791
|
|
|
2114
2792
|
@property
|
|
2115
2793
|
@pulumi.getter(name="memoryOversubscription")
|
|
2116
|
-
def memory_oversubscription(self) -> Optional[pulumi.Input[str]]:
|
|
2794
|
+
def memory_oversubscription(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
2117
2795
|
"""
|
|
2118
2796
|
`(string)` - Whether or not memory
|
|
2119
2797
|
oversubscription is enabled in the node pool. Possible values are
|
|
@@ -2127,12 +2805,12 @@ class NodePoolSchedulerConfigArgs:
|
|
|
2127
2805
|
return pulumi.get(self, "memory_oversubscription")
|
|
2128
2806
|
|
|
2129
2807
|
@memory_oversubscription.setter
|
|
2130
|
-
def memory_oversubscription(self, value: Optional[pulumi.Input[str]]):
|
|
2808
|
+
def memory_oversubscription(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
2131
2809
|
pulumi.set(self, "memory_oversubscription", value)
|
|
2132
2810
|
|
|
2133
2811
|
@property
|
|
2134
2812
|
@pulumi.getter(name="schedulerAlgorithm")
|
|
2135
|
-
def scheduler_algorithm(self) -> Optional[pulumi.Input[str]]:
|
|
2813
|
+
def scheduler_algorithm(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
2136
2814
|
"""
|
|
2137
2815
|
`(string)` - The scheduler algorithm used in the node
|
|
2138
2816
|
pool. Possible values are `binpack` or `spread`. If not defined the global
|
|
@@ -2141,17 +2819,17 @@ class NodePoolSchedulerConfigArgs:
|
|
|
2141
2819
|
return pulumi.get(self, "scheduler_algorithm")
|
|
2142
2820
|
|
|
2143
2821
|
@scheduler_algorithm.setter
|
|
2144
|
-
def scheduler_algorithm(self, value: Optional[pulumi.Input[str]]):
|
|
2822
|
+
def scheduler_algorithm(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
2145
2823
|
pulumi.set(self, "scheduler_algorithm", value)
|
|
2146
2824
|
|
|
2147
2825
|
|
|
2148
2826
|
if not MYPY:
|
|
2149
2827
|
class ProviderHeaderArgsDict(TypedDict):
|
|
2150
|
-
name: pulumi.Input[str]
|
|
2828
|
+
name: pulumi.Input[builtins.str]
|
|
2151
2829
|
"""
|
|
2152
2830
|
The header name
|
|
2153
2831
|
"""
|
|
2154
|
-
value: pulumi.Input[str]
|
|
2832
|
+
value: pulumi.Input[builtins.str]
|
|
2155
2833
|
"""
|
|
2156
2834
|
The header value
|
|
2157
2835
|
"""
|
|
@@ -2161,43 +2839,43 @@ elif False:
|
|
|
2161
2839
|
@pulumi.input_type
|
|
2162
2840
|
class ProviderHeaderArgs:
|
|
2163
2841
|
def __init__(__self__, *,
|
|
2164
|
-
name: pulumi.Input[str],
|
|
2165
|
-
value: pulumi.Input[str]):
|
|
2842
|
+
name: pulumi.Input[builtins.str],
|
|
2843
|
+
value: pulumi.Input[builtins.str]):
|
|
2166
2844
|
"""
|
|
2167
|
-
:param pulumi.Input[str] name: The header name
|
|
2168
|
-
:param pulumi.Input[str] value: The header value
|
|
2845
|
+
:param pulumi.Input[builtins.str] name: The header name
|
|
2846
|
+
:param pulumi.Input[builtins.str] value: The header value
|
|
2169
2847
|
"""
|
|
2170
2848
|
pulumi.set(__self__, "name", name)
|
|
2171
2849
|
pulumi.set(__self__, "value", value)
|
|
2172
2850
|
|
|
2173
2851
|
@property
|
|
2174
2852
|
@pulumi.getter
|
|
2175
|
-
def name(self) -> pulumi.Input[str]:
|
|
2853
|
+
def name(self) -> pulumi.Input[builtins.str]:
|
|
2176
2854
|
"""
|
|
2177
2855
|
The header name
|
|
2178
2856
|
"""
|
|
2179
2857
|
return pulumi.get(self, "name")
|
|
2180
2858
|
|
|
2181
2859
|
@name.setter
|
|
2182
|
-
def name(self, value: pulumi.Input[str]):
|
|
2860
|
+
def name(self, value: pulumi.Input[builtins.str]):
|
|
2183
2861
|
pulumi.set(self, "name", value)
|
|
2184
2862
|
|
|
2185
2863
|
@property
|
|
2186
2864
|
@pulumi.getter
|
|
2187
|
-
def value(self) -> pulumi.Input[str]:
|
|
2865
|
+
def value(self) -> pulumi.Input[builtins.str]:
|
|
2188
2866
|
"""
|
|
2189
2867
|
The header value
|
|
2190
2868
|
"""
|
|
2191
2869
|
return pulumi.get(self, "value")
|
|
2192
2870
|
|
|
2193
2871
|
@value.setter
|
|
2194
|
-
def value(self, value: pulumi.Input[str]):
|
|
2872
|
+
def value(self, value: pulumi.Input[builtins.str]):
|
|
2195
2873
|
pulumi.set(self, "value", value)
|
|
2196
2874
|
|
|
2197
2875
|
|
|
2198
2876
|
if not MYPY:
|
|
2199
2877
|
class QuoteSpecificationLimitArgsDict(TypedDict):
|
|
2200
|
-
region: pulumi.Input[str]
|
|
2878
|
+
region: pulumi.Input[builtins.str]
|
|
2201
2879
|
"""
|
|
2202
2880
|
`(string: <required>)` - The region these limits should apply to.
|
|
2203
2881
|
"""
|
|
@@ -2213,10 +2891,10 @@ elif False:
|
|
|
2213
2891
|
@pulumi.input_type
|
|
2214
2892
|
class QuoteSpecificationLimitArgs:
|
|
2215
2893
|
def __init__(__self__, *,
|
|
2216
|
-
region: pulumi.Input[str],
|
|
2894
|
+
region: pulumi.Input[builtins.str],
|
|
2217
2895
|
region_limit: pulumi.Input['QuoteSpecificationLimitRegionLimitArgs']):
|
|
2218
2896
|
"""
|
|
2219
|
-
:param pulumi.Input[str] region: `(string: <required>)` - The region these limits should apply to.
|
|
2897
|
+
:param pulumi.Input[builtins.str] region: `(string: <required>)` - The region these limits should apply to.
|
|
2220
2898
|
:param pulumi.Input['QuoteSpecificationLimitRegionLimitArgs'] region_limit: `(block: <required>)` - The limits to enforce. This block
|
|
2221
2899
|
may only be specified once in the `limits` block. Its structure is
|
|
2222
2900
|
documented below.
|
|
@@ -2226,14 +2904,14 @@ class QuoteSpecificationLimitArgs:
|
|
|
2226
2904
|
|
|
2227
2905
|
@property
|
|
2228
2906
|
@pulumi.getter
|
|
2229
|
-
def region(self) -> pulumi.Input[str]:
|
|
2907
|
+
def region(self) -> pulumi.Input[builtins.str]:
|
|
2230
2908
|
"""
|
|
2231
2909
|
`(string: <required>)` - The region these limits should apply to.
|
|
2232
2910
|
"""
|
|
2233
2911
|
return pulumi.get(self, "region")
|
|
2234
2912
|
|
|
2235
2913
|
@region.setter
|
|
2236
|
-
def region(self, value: pulumi.Input[str]):
|
|
2914
|
+
def region(self, value: pulumi.Input[builtins.str]):
|
|
2237
2915
|
pulumi.set(self, "region", value)
|
|
2238
2916
|
|
|
2239
2917
|
@property
|
|
@@ -2253,12 +2931,12 @@ class QuoteSpecificationLimitArgs:
|
|
|
2253
2931
|
|
|
2254
2932
|
if not MYPY:
|
|
2255
2933
|
class QuoteSpecificationLimitRegionLimitArgsDict(TypedDict):
|
|
2256
|
-
cpu: NotRequired[pulumi.Input[int]]
|
|
2934
|
+
cpu: NotRequired[pulumi.Input[builtins.int]]
|
|
2257
2935
|
"""
|
|
2258
2936
|
`(int: 0)` - The amount of CPU to limit allocations to. A value of zero
|
|
2259
2937
|
is treated as unlimited, and a negative value is treated as fully disallowed.
|
|
2260
2938
|
"""
|
|
2261
|
-
memory_mb: NotRequired[pulumi.Input[int]]
|
|
2939
|
+
memory_mb: NotRequired[pulumi.Input[builtins.int]]
|
|
2262
2940
|
"""
|
|
2263
2941
|
`(int: 0)` - The amount of memory (in megabytes) to limit
|
|
2264
2942
|
allocations to. A value of zero is treated as unlimited, and a negative value
|
|
@@ -2270,12 +2948,12 @@ elif False:
|
|
|
2270
2948
|
@pulumi.input_type
|
|
2271
2949
|
class QuoteSpecificationLimitRegionLimitArgs:
|
|
2272
2950
|
def __init__(__self__, *,
|
|
2273
|
-
cpu: Optional[pulumi.Input[int]] = None,
|
|
2274
|
-
memory_mb: Optional[pulumi.Input[int]] = None):
|
|
2951
|
+
cpu: Optional[pulumi.Input[builtins.int]] = None,
|
|
2952
|
+
memory_mb: Optional[pulumi.Input[builtins.int]] = None):
|
|
2275
2953
|
"""
|
|
2276
|
-
:param pulumi.Input[int] cpu: `(int: 0)` - The amount of CPU to limit allocations to. A value of zero
|
|
2954
|
+
:param pulumi.Input[builtins.int] cpu: `(int: 0)` - The amount of CPU to limit allocations to. A value of zero
|
|
2277
2955
|
is treated as unlimited, and a negative value is treated as fully disallowed.
|
|
2278
|
-
:param pulumi.Input[int] memory_mb: `(int: 0)` - The amount of memory (in megabytes) to limit
|
|
2956
|
+
:param pulumi.Input[builtins.int] memory_mb: `(int: 0)` - The amount of memory (in megabytes) to limit
|
|
2279
2957
|
allocations to. A value of zero is treated as unlimited, and a negative value
|
|
2280
2958
|
is treated as fully disallowed.
|
|
2281
2959
|
"""
|
|
@@ -2286,7 +2964,7 @@ class QuoteSpecificationLimitRegionLimitArgs:
|
|
|
2286
2964
|
|
|
2287
2965
|
@property
|
|
2288
2966
|
@pulumi.getter
|
|
2289
|
-
def cpu(self) -> Optional[pulumi.Input[int]]:
|
|
2967
|
+
def cpu(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
2290
2968
|
"""
|
|
2291
2969
|
`(int: 0)` - The amount of CPU to limit allocations to. A value of zero
|
|
2292
2970
|
is treated as unlimited, and a negative value is treated as fully disallowed.
|
|
@@ -2294,12 +2972,12 @@ class QuoteSpecificationLimitRegionLimitArgs:
|
|
|
2294
2972
|
return pulumi.get(self, "cpu")
|
|
2295
2973
|
|
|
2296
2974
|
@cpu.setter
|
|
2297
|
-
def cpu(self, value: Optional[pulumi.Input[int]]):
|
|
2975
|
+
def cpu(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
2298
2976
|
pulumi.set(self, "cpu", value)
|
|
2299
2977
|
|
|
2300
2978
|
@property
|
|
2301
2979
|
@pulumi.getter(name="memoryMb")
|
|
2302
|
-
def memory_mb(self) -> Optional[pulumi.Input[int]]:
|
|
2980
|
+
def memory_mb(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
2303
2981
|
"""
|
|
2304
2982
|
`(int: 0)` - The amount of memory (in megabytes) to limit
|
|
2305
2983
|
allocations to. A value of zero is treated as unlimited, and a negative value
|
|
@@ -2308,13 +2986,13 @@ class QuoteSpecificationLimitRegionLimitArgs:
|
|
|
2308
2986
|
return pulumi.get(self, "memory_mb")
|
|
2309
2987
|
|
|
2310
2988
|
@memory_mb.setter
|
|
2311
|
-
def memory_mb(self, value: Optional[pulumi.Input[int]]):
|
|
2989
|
+
def memory_mb(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
2312
2990
|
pulumi.set(self, "memory_mb", value)
|
|
2313
2991
|
|
|
2314
2992
|
|
|
2315
2993
|
if not MYPY:
|
|
2316
2994
|
class VolumeCapabilityArgsDict(TypedDict):
|
|
2317
|
-
access_mode: pulumi.Input[str]
|
|
2995
|
+
access_mode: pulumi.Input[builtins.str]
|
|
2318
2996
|
"""
|
|
2319
2997
|
`(string: <required>)` - Defines whether a volume should be available concurrently. Possible values are:
|
|
2320
2998
|
- `single-node-reader-only`
|
|
@@ -2323,7 +3001,7 @@ if not MYPY:
|
|
|
2323
3001
|
- `multi-node-single-writer`
|
|
2324
3002
|
- `multi-node-multi-writer`
|
|
2325
3003
|
"""
|
|
2326
|
-
attachment_mode: pulumi.Input[str]
|
|
3004
|
+
attachment_mode: pulumi.Input[builtins.str]
|
|
2327
3005
|
"""
|
|
2328
3006
|
`(string: <required>)` - The storage API that will be used by the volume. Possible values are:
|
|
2329
3007
|
- `block-device`
|
|
@@ -2335,16 +3013,16 @@ elif False:
|
|
|
2335
3013
|
@pulumi.input_type
|
|
2336
3014
|
class VolumeCapabilityArgs:
|
|
2337
3015
|
def __init__(__self__, *,
|
|
2338
|
-
access_mode: pulumi.Input[str],
|
|
2339
|
-
attachment_mode: pulumi.Input[str]):
|
|
3016
|
+
access_mode: pulumi.Input[builtins.str],
|
|
3017
|
+
attachment_mode: pulumi.Input[builtins.str]):
|
|
2340
3018
|
"""
|
|
2341
|
-
:param pulumi.Input[str] access_mode: `(string: <required>)` - Defines whether a volume should be available concurrently. Possible values are:
|
|
3019
|
+
:param pulumi.Input[builtins.str] access_mode: `(string: <required>)` - Defines whether a volume should be available concurrently. Possible values are:
|
|
2342
3020
|
- `single-node-reader-only`
|
|
2343
3021
|
- `single-node-writer`
|
|
2344
3022
|
- `multi-node-reader-only`
|
|
2345
3023
|
- `multi-node-single-writer`
|
|
2346
3024
|
- `multi-node-multi-writer`
|
|
2347
|
-
:param pulumi.Input[str] attachment_mode: `(string: <required>)` - The storage API that will be used by the volume. Possible values are:
|
|
3025
|
+
:param pulumi.Input[builtins.str] attachment_mode: `(string: <required>)` - The storage API that will be used by the volume. Possible values are:
|
|
2348
3026
|
- `block-device`
|
|
2349
3027
|
- `file-system`
|
|
2350
3028
|
"""
|
|
@@ -2353,7 +3031,7 @@ class VolumeCapabilityArgs:
|
|
|
2353
3031
|
|
|
2354
3032
|
@property
|
|
2355
3033
|
@pulumi.getter(name="accessMode")
|
|
2356
|
-
def access_mode(self) -> pulumi.Input[str]:
|
|
3034
|
+
def access_mode(self) -> pulumi.Input[builtins.str]:
|
|
2357
3035
|
"""
|
|
2358
3036
|
`(string: <required>)` - Defines whether a volume should be available concurrently. Possible values are:
|
|
2359
3037
|
- `single-node-reader-only`
|
|
@@ -2365,12 +3043,12 @@ class VolumeCapabilityArgs:
|
|
|
2365
3043
|
return pulumi.get(self, "access_mode")
|
|
2366
3044
|
|
|
2367
3045
|
@access_mode.setter
|
|
2368
|
-
def access_mode(self, value: pulumi.Input[str]):
|
|
3046
|
+
def access_mode(self, value: pulumi.Input[builtins.str]):
|
|
2369
3047
|
pulumi.set(self, "access_mode", value)
|
|
2370
3048
|
|
|
2371
3049
|
@property
|
|
2372
3050
|
@pulumi.getter(name="attachmentMode")
|
|
2373
|
-
def attachment_mode(self) -> pulumi.Input[str]:
|
|
3051
|
+
def attachment_mode(self) -> pulumi.Input[builtins.str]:
|
|
2374
3052
|
"""
|
|
2375
3053
|
`(string: <required>)` - The storage API that will be used by the volume. Possible values are:
|
|
2376
3054
|
- `block-device`
|
|
@@ -2379,17 +3057,17 @@ class VolumeCapabilityArgs:
|
|
|
2379
3057
|
return pulumi.get(self, "attachment_mode")
|
|
2380
3058
|
|
|
2381
3059
|
@attachment_mode.setter
|
|
2382
|
-
def attachment_mode(self, value: pulumi.Input[str]):
|
|
3060
|
+
def attachment_mode(self, value: pulumi.Input[builtins.str]):
|
|
2383
3061
|
pulumi.set(self, "attachment_mode", value)
|
|
2384
3062
|
|
|
2385
3063
|
|
|
2386
3064
|
if not MYPY:
|
|
2387
3065
|
class VolumeMountOptionsArgsDict(TypedDict):
|
|
2388
|
-
fs_type: NotRequired[pulumi.Input[str]]
|
|
3066
|
+
fs_type: NotRequired[pulumi.Input[builtins.str]]
|
|
2389
3067
|
"""
|
|
2390
3068
|
`(string: <optional>)` - The file system type.
|
|
2391
3069
|
"""
|
|
2392
|
-
mount_flags: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
3070
|
+
mount_flags: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
|
|
2393
3071
|
"""
|
|
2394
3072
|
`([]string: <optional>)` - The flags passed to `mount`.
|
|
2395
3073
|
"""
|
|
@@ -2399,11 +3077,11 @@ elif False:
|
|
|
2399
3077
|
@pulumi.input_type
|
|
2400
3078
|
class VolumeMountOptionsArgs:
|
|
2401
3079
|
def __init__(__self__, *,
|
|
2402
|
-
fs_type: Optional[pulumi.Input[str]] = None,
|
|
2403
|
-
mount_flags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
|
|
3080
|
+
fs_type: Optional[pulumi.Input[builtins.str]] = None,
|
|
3081
|
+
mount_flags: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None):
|
|
2404
3082
|
"""
|
|
2405
|
-
:param pulumi.Input[str] fs_type: `(string: <optional>)` - The file system type.
|
|
2406
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] mount_flags: `([]string: <optional>)` - The flags passed to `mount`.
|
|
3083
|
+
:param pulumi.Input[builtins.str] fs_type: `(string: <optional>)` - The file system type.
|
|
3084
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] mount_flags: `([]string: <optional>)` - The flags passed to `mount`.
|
|
2407
3085
|
"""
|
|
2408
3086
|
if fs_type is not None:
|
|
2409
3087
|
pulumi.set(__self__, "fs_type", fs_type)
|
|
@@ -2412,32 +3090,32 @@ class VolumeMountOptionsArgs:
|
|
|
2412
3090
|
|
|
2413
3091
|
@property
|
|
2414
3092
|
@pulumi.getter(name="fsType")
|
|
2415
|
-
def fs_type(self) -> Optional[pulumi.Input[str]]:
|
|
3093
|
+
def fs_type(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
2416
3094
|
"""
|
|
2417
3095
|
`(string: <optional>)` - The file system type.
|
|
2418
3096
|
"""
|
|
2419
3097
|
return pulumi.get(self, "fs_type")
|
|
2420
3098
|
|
|
2421
3099
|
@fs_type.setter
|
|
2422
|
-
def fs_type(self, value: Optional[pulumi.Input[str]]):
|
|
3100
|
+
def fs_type(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
2423
3101
|
pulumi.set(self, "fs_type", value)
|
|
2424
3102
|
|
|
2425
3103
|
@property
|
|
2426
3104
|
@pulumi.getter(name="mountFlags")
|
|
2427
|
-
def mount_flags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
3105
|
+
def mount_flags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
2428
3106
|
"""
|
|
2429
3107
|
`([]string: <optional>)` - The flags passed to `mount`.
|
|
2430
3108
|
"""
|
|
2431
3109
|
return pulumi.get(self, "mount_flags")
|
|
2432
3110
|
|
|
2433
3111
|
@mount_flags.setter
|
|
2434
|
-
def mount_flags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
3112
|
+
def mount_flags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
2435
3113
|
pulumi.set(self, "mount_flags", value)
|
|
2436
3114
|
|
|
2437
3115
|
|
|
2438
3116
|
if not MYPY:
|
|
2439
3117
|
class VolumeTopologyArgsDict(TypedDict):
|
|
2440
|
-
segments: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
3118
|
+
segments: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]
|
|
2441
3119
|
"""
|
|
2442
3120
|
`(map[string]string)` - Define the attributes for the topology request.
|
|
2443
3121
|
|
|
@@ -2450,9 +3128,9 @@ elif False:
|
|
|
2450
3128
|
@pulumi.input_type
|
|
2451
3129
|
class VolumeTopologyArgs:
|
|
2452
3130
|
def __init__(__self__, *,
|
|
2453
|
-
segments: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None):
|
|
3131
|
+
segments: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None):
|
|
2454
3132
|
"""
|
|
2455
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] segments: `(map[string]string)` - Define the attributes for the topology request.
|
|
3133
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] segments: `(map[string]string)` - Define the attributes for the topology request.
|
|
2456
3134
|
|
|
2457
3135
|
In addition to the above arguments, the following attributes are exported and
|
|
2458
3136
|
can be referenced:
|
|
@@ -2462,7 +3140,7 @@ class VolumeTopologyArgs:
|
|
|
2462
3140
|
|
|
2463
3141
|
@property
|
|
2464
3142
|
@pulumi.getter
|
|
2465
|
-
def segments(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
3143
|
+
def segments(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]:
|
|
2466
3144
|
"""
|
|
2467
3145
|
`(map[string]string)` - Define the attributes for the topology request.
|
|
2468
3146
|
|
|
@@ -2472,7 +3150,7 @@ class VolumeTopologyArgs:
|
|
|
2472
3150
|
return pulumi.get(self, "segments")
|
|
2473
3151
|
|
|
2474
3152
|
@segments.setter
|
|
2475
|
-
def segments(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
3153
|
+
def segments(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]):
|
|
2476
3154
|
pulumi.set(self, "segments", value)
|
|
2477
3155
|
|
|
2478
3156
|
|
|
@@ -2541,7 +3219,7 @@ class VolumeTopologyRequestRequiredArgs:
|
|
|
2541
3219
|
|
|
2542
3220
|
if not MYPY:
|
|
2543
3221
|
class VolumeTopologyRequestRequiredTopologyArgsDict(TypedDict):
|
|
2544
|
-
segments: pulumi.Input[Mapping[str, pulumi.Input[str]]]
|
|
3222
|
+
segments: pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]
|
|
2545
3223
|
"""
|
|
2546
3224
|
Define attributes for the topology request.
|
|
2547
3225
|
"""
|
|
@@ -2551,22 +3229,22 @@ elif False:
|
|
|
2551
3229
|
@pulumi.input_type
|
|
2552
3230
|
class VolumeTopologyRequestRequiredTopologyArgs:
|
|
2553
3231
|
def __init__(__self__, *,
|
|
2554
|
-
segments: pulumi.Input[Mapping[str, pulumi.Input[str]]]):
|
|
3232
|
+
segments: pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]):
|
|
2555
3233
|
"""
|
|
2556
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] segments: Define attributes for the topology request.
|
|
3234
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] segments: Define attributes for the topology request.
|
|
2557
3235
|
"""
|
|
2558
3236
|
pulumi.set(__self__, "segments", segments)
|
|
2559
3237
|
|
|
2560
3238
|
@property
|
|
2561
3239
|
@pulumi.getter
|
|
2562
|
-
def segments(self) -> pulumi.Input[Mapping[str, pulumi.Input[str]]]:
|
|
3240
|
+
def segments(self) -> pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]:
|
|
2563
3241
|
"""
|
|
2564
3242
|
Define attributes for the topology request.
|
|
2565
3243
|
"""
|
|
2566
3244
|
return pulumi.get(self, "segments")
|
|
2567
3245
|
|
|
2568
3246
|
@segments.setter
|
|
2569
|
-
def segments(self, value: pulumi.Input[Mapping[str, pulumi.Input[str]]]):
|
|
3247
|
+
def segments(self, value: pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]):
|
|
2570
3248
|
pulumi.set(self, "segments", value)
|
|
2571
3249
|
|
|
2572
3250
|
|