pulumi-vault 7.2.0a1755297899__py3-none-any.whl → 7.2.0a1755574606__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_vault/__init__.py +18 -0
- pulumi_vault/_inputs.py +201 -0
- pulumi_vault/aws/secret_backend.py +627 -49
- pulumi_vault/azure/backend.py +788 -15
- pulumi_vault/consul/secret_backend.py +660 -28
- pulumi_vault/database/secrets_mount.py +47 -0
- pulumi_vault/gcp/secret_backend.py +599 -56
- pulumi_vault/jwt/auth_backend.py +47 -0
- pulumi_vault/kmip/secret_backend.py +787 -7
- pulumi_vault/kubernetes/secret_backend.py +47 -0
- pulumi_vault/ldap/secret_backend.py +75 -35
- pulumi_vault/mount.py +47 -0
- pulumi_vault/nomad_secret_backend.py +660 -21
- pulumi_vault/oci_auth_backend.py +683 -0
- pulumi_vault/oci_auth_backend_role.py +798 -0
- pulumi_vault/outputs.py +153 -0
- pulumi_vault/pkisecret/backend_config_scep.py +68 -21
- pulumi_vault/pkisecret/get_backend_config_scep.py +21 -1
- pulumi_vault/pulumi-plugin.json +1 -1
- pulumi_vault/rabbitmq/secret_backend.py +707 -35
- pulumi_vault/ssh/secret_backend_ca.py +101 -7
- pulumi_vault/terraformcloud/secret_backend.py +707 -28
- pulumi_vault/transit/secret_backend_key.py +49 -21
- {pulumi_vault-7.2.0a1755297899.dist-info → pulumi_vault-7.2.0a1755574606.dist-info}/METADATA +1 -1
- {pulumi_vault-7.2.0a1755297899.dist-info → pulumi_vault-7.2.0a1755574606.dist-info}/RECORD +27 -25
- {pulumi_vault-7.2.0a1755297899.dist-info → pulumi_vault-7.2.0a1755574606.dist-info}/WHEEL +0 -0
- {pulumi_vault-7.2.0a1755297899.dist-info → pulumi_vault-7.2.0a1755574606.dist-info}/top_level.txt +0 -0
|
@@ -22,13 +22,27 @@ class SecretBackendArgs:
|
|
|
22
22
|
connection_uri: pulumi.Input[_builtins.str],
|
|
23
23
|
password: pulumi.Input[_builtins.str],
|
|
24
24
|
username: pulumi.Input[_builtins.str],
|
|
25
|
+
allowed_managed_keys: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
26
|
+
allowed_response_headers: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
27
|
+
audit_non_hmac_request_keys: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
28
|
+
audit_non_hmac_response_keys: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
25
29
|
default_lease_ttl_seconds: Optional[pulumi.Input[_builtins.int]] = None,
|
|
30
|
+
delegated_auth_accessors: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
26
31
|
description: Optional[pulumi.Input[_builtins.str]] = None,
|
|
27
32
|
disable_remount: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
33
|
+
external_entropy_access: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
34
|
+
force_no_cache: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
35
|
+
identity_token_key: Optional[pulumi.Input[_builtins.str]] = None,
|
|
36
|
+
listing_visibility: Optional[pulumi.Input[_builtins.str]] = None,
|
|
37
|
+
local: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
28
38
|
max_lease_ttl_seconds: Optional[pulumi.Input[_builtins.int]] = None,
|
|
29
39
|
namespace: Optional[pulumi.Input[_builtins.str]] = None,
|
|
40
|
+
options: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
|
|
41
|
+
passthrough_request_headers: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
30
42
|
password_policy: Optional[pulumi.Input[_builtins.str]] = None,
|
|
31
43
|
path: Optional[pulumi.Input[_builtins.str]] = None,
|
|
44
|
+
plugin_version: Optional[pulumi.Input[_builtins.str]] = None,
|
|
45
|
+
seal_wrap: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
32
46
|
username_template: Optional[pulumi.Input[_builtins.str]] = None,
|
|
33
47
|
verify_connection: Optional[pulumi.Input[_builtins.bool]] = None):
|
|
34
48
|
"""
|
|
@@ -36,20 +50,32 @@ class SecretBackendArgs:
|
|
|
36
50
|
:param pulumi.Input[_builtins.str] connection_uri: Specifies the RabbitMQ connection URI.
|
|
37
51
|
:param pulumi.Input[_builtins.str] password: Specifies the RabbitMQ management administrator password.
|
|
38
52
|
:param pulumi.Input[_builtins.str] username: Specifies the RabbitMQ management administrator username.
|
|
39
|
-
:param pulumi.Input[_builtins.
|
|
40
|
-
|
|
41
|
-
:param pulumi.Input[_builtins.str]
|
|
53
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] allowed_managed_keys: List of managed key registry entry names that the mount in question is allowed to access
|
|
54
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] allowed_response_headers: List of headers to allow and pass from the request to the plugin
|
|
55
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] audit_non_hmac_request_keys: Specifies the list of keys that will not be HMAC'd by audit devices in the request data object.
|
|
56
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] audit_non_hmac_response_keys: Specifies the list of keys that will not be HMAC'd by audit devices in the response data object.
|
|
57
|
+
:param pulumi.Input[_builtins.int] default_lease_ttl_seconds: Default lease duration for secrets in seconds
|
|
58
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] delegated_auth_accessors: List of headers to allow and pass from the request to the plugin
|
|
59
|
+
:param pulumi.Input[_builtins.str] description: Human-friendly description of the mount for the backend.
|
|
42
60
|
:param pulumi.Input[_builtins.bool] disable_remount: If set, opts out of mount migration on path updates.
|
|
43
61
|
See here for more info on [Mount Migration](https://www.vaultproject.io/docs/concepts/mount-migration)
|
|
44
|
-
:param pulumi.Input[_builtins.
|
|
45
|
-
|
|
62
|
+
:param pulumi.Input[_builtins.bool] external_entropy_access: Enable the secrets engine to access Vault's external entropy source
|
|
63
|
+
:param pulumi.Input[_builtins.bool] force_no_cache: If set to true, disables caching.
|
|
64
|
+
:param pulumi.Input[_builtins.str] identity_token_key: The key to use for signing plugin workload identity tokens
|
|
65
|
+
:param pulumi.Input[_builtins.str] listing_visibility: Specifies whether to show this mount in the UI-specific listing endpoint
|
|
66
|
+
:param pulumi.Input[_builtins.bool] local: Local mount flag that can be explicitly set to true to enforce local mount in HA environment
|
|
67
|
+
:param pulumi.Input[_builtins.int] max_lease_ttl_seconds: Maximum possible lease duration for secrets in seconds
|
|
46
68
|
:param pulumi.Input[_builtins.str] namespace: The namespace to provision the resource in.
|
|
47
69
|
The value should not contain leading or trailing forward slashes.
|
|
48
70
|
The `namespace` is always relative to the provider's configured [namespace](https://www.terraform.io/docs/providers/vault/index.html#namespace).
|
|
49
71
|
*Available only for Vault Enterprise*.
|
|
72
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] options: Specifies mount type specific options that are passed to the backend
|
|
73
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] passthrough_request_headers: List of headers to allow and pass from the request to the plugin
|
|
50
74
|
:param pulumi.Input[_builtins.str] password_policy: Specifies a password policy to use when creating dynamic credentials. Defaults to generating an alphanumeric password if not set.
|
|
51
75
|
:param pulumi.Input[_builtins.str] path: The unique path this backend should be mounted at. Must
|
|
52
76
|
not begin or end with a `/`. Defaults to `rabbitmq`.
|
|
77
|
+
:param pulumi.Input[_builtins.str] plugin_version: Specifies the semantic version of the plugin to use, e.g. 'v1.0.0'
|
|
78
|
+
:param pulumi.Input[_builtins.bool] seal_wrap: Enable seal wrapping for the mount, causing values stored by the mount to be wrapped by the seal's encryption capability
|
|
53
79
|
:param pulumi.Input[_builtins.str] username_template: Template describing how dynamic usernames are generated.
|
|
54
80
|
:param pulumi.Input[_builtins.bool] verify_connection: Specifies whether to verify connection URI, username, and password.
|
|
55
81
|
Defaults to `true`.
|
|
@@ -57,20 +83,48 @@ class SecretBackendArgs:
|
|
|
57
83
|
pulumi.set(__self__, "connection_uri", connection_uri)
|
|
58
84
|
pulumi.set(__self__, "password", password)
|
|
59
85
|
pulumi.set(__self__, "username", username)
|
|
86
|
+
if allowed_managed_keys is not None:
|
|
87
|
+
pulumi.set(__self__, "allowed_managed_keys", allowed_managed_keys)
|
|
88
|
+
if allowed_response_headers is not None:
|
|
89
|
+
pulumi.set(__self__, "allowed_response_headers", allowed_response_headers)
|
|
90
|
+
if audit_non_hmac_request_keys is not None:
|
|
91
|
+
pulumi.set(__self__, "audit_non_hmac_request_keys", audit_non_hmac_request_keys)
|
|
92
|
+
if audit_non_hmac_response_keys is not None:
|
|
93
|
+
pulumi.set(__self__, "audit_non_hmac_response_keys", audit_non_hmac_response_keys)
|
|
60
94
|
if default_lease_ttl_seconds is not None:
|
|
61
95
|
pulumi.set(__self__, "default_lease_ttl_seconds", default_lease_ttl_seconds)
|
|
96
|
+
if delegated_auth_accessors is not None:
|
|
97
|
+
pulumi.set(__self__, "delegated_auth_accessors", delegated_auth_accessors)
|
|
62
98
|
if description is not None:
|
|
63
99
|
pulumi.set(__self__, "description", description)
|
|
64
100
|
if disable_remount is not None:
|
|
65
101
|
pulumi.set(__self__, "disable_remount", disable_remount)
|
|
102
|
+
if external_entropy_access is not None:
|
|
103
|
+
pulumi.set(__self__, "external_entropy_access", external_entropy_access)
|
|
104
|
+
if force_no_cache is not None:
|
|
105
|
+
pulumi.set(__self__, "force_no_cache", force_no_cache)
|
|
106
|
+
if identity_token_key is not None:
|
|
107
|
+
pulumi.set(__self__, "identity_token_key", identity_token_key)
|
|
108
|
+
if listing_visibility is not None:
|
|
109
|
+
pulumi.set(__self__, "listing_visibility", listing_visibility)
|
|
110
|
+
if local is not None:
|
|
111
|
+
pulumi.set(__self__, "local", local)
|
|
66
112
|
if max_lease_ttl_seconds is not None:
|
|
67
113
|
pulumi.set(__self__, "max_lease_ttl_seconds", max_lease_ttl_seconds)
|
|
68
114
|
if namespace is not None:
|
|
69
115
|
pulumi.set(__self__, "namespace", namespace)
|
|
116
|
+
if options is not None:
|
|
117
|
+
pulumi.set(__self__, "options", options)
|
|
118
|
+
if passthrough_request_headers is not None:
|
|
119
|
+
pulumi.set(__self__, "passthrough_request_headers", passthrough_request_headers)
|
|
70
120
|
if password_policy is not None:
|
|
71
121
|
pulumi.set(__self__, "password_policy", password_policy)
|
|
72
122
|
if path is not None:
|
|
73
123
|
pulumi.set(__self__, "path", path)
|
|
124
|
+
if plugin_version is not None:
|
|
125
|
+
pulumi.set(__self__, "plugin_version", plugin_version)
|
|
126
|
+
if seal_wrap is not None:
|
|
127
|
+
pulumi.set(__self__, "seal_wrap", seal_wrap)
|
|
74
128
|
if username_template is not None:
|
|
75
129
|
pulumi.set(__self__, "username_template", username_template)
|
|
76
130
|
if verify_connection is not None:
|
|
@@ -112,12 +166,59 @@ class SecretBackendArgs:
|
|
|
112
166
|
def username(self, value: pulumi.Input[_builtins.str]):
|
|
113
167
|
pulumi.set(self, "username", value)
|
|
114
168
|
|
|
169
|
+
@_builtins.property
|
|
170
|
+
@pulumi.getter(name="allowedManagedKeys")
|
|
171
|
+
def allowed_managed_keys(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
172
|
+
"""
|
|
173
|
+
List of managed key registry entry names that the mount in question is allowed to access
|
|
174
|
+
"""
|
|
175
|
+
return pulumi.get(self, "allowed_managed_keys")
|
|
176
|
+
|
|
177
|
+
@allowed_managed_keys.setter
|
|
178
|
+
def allowed_managed_keys(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
179
|
+
pulumi.set(self, "allowed_managed_keys", value)
|
|
180
|
+
|
|
181
|
+
@_builtins.property
|
|
182
|
+
@pulumi.getter(name="allowedResponseHeaders")
|
|
183
|
+
def allowed_response_headers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
184
|
+
"""
|
|
185
|
+
List of headers to allow and pass from the request to the plugin
|
|
186
|
+
"""
|
|
187
|
+
return pulumi.get(self, "allowed_response_headers")
|
|
188
|
+
|
|
189
|
+
@allowed_response_headers.setter
|
|
190
|
+
def allowed_response_headers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
191
|
+
pulumi.set(self, "allowed_response_headers", value)
|
|
192
|
+
|
|
193
|
+
@_builtins.property
|
|
194
|
+
@pulumi.getter(name="auditNonHmacRequestKeys")
|
|
195
|
+
def audit_non_hmac_request_keys(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
196
|
+
"""
|
|
197
|
+
Specifies the list of keys that will not be HMAC'd by audit devices in the request data object.
|
|
198
|
+
"""
|
|
199
|
+
return pulumi.get(self, "audit_non_hmac_request_keys")
|
|
200
|
+
|
|
201
|
+
@audit_non_hmac_request_keys.setter
|
|
202
|
+
def audit_non_hmac_request_keys(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
203
|
+
pulumi.set(self, "audit_non_hmac_request_keys", value)
|
|
204
|
+
|
|
205
|
+
@_builtins.property
|
|
206
|
+
@pulumi.getter(name="auditNonHmacResponseKeys")
|
|
207
|
+
def audit_non_hmac_response_keys(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
208
|
+
"""
|
|
209
|
+
Specifies the list of keys that will not be HMAC'd by audit devices in the response data object.
|
|
210
|
+
"""
|
|
211
|
+
return pulumi.get(self, "audit_non_hmac_response_keys")
|
|
212
|
+
|
|
213
|
+
@audit_non_hmac_response_keys.setter
|
|
214
|
+
def audit_non_hmac_response_keys(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
215
|
+
pulumi.set(self, "audit_non_hmac_response_keys", value)
|
|
216
|
+
|
|
115
217
|
@_builtins.property
|
|
116
218
|
@pulumi.getter(name="defaultLeaseTtlSeconds")
|
|
117
219
|
def default_lease_ttl_seconds(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
118
220
|
"""
|
|
119
|
-
|
|
120
|
-
issued by this backend.
|
|
221
|
+
Default lease duration for secrets in seconds
|
|
121
222
|
"""
|
|
122
223
|
return pulumi.get(self, "default_lease_ttl_seconds")
|
|
123
224
|
|
|
@@ -125,11 +226,23 @@ class SecretBackendArgs:
|
|
|
125
226
|
def default_lease_ttl_seconds(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
126
227
|
pulumi.set(self, "default_lease_ttl_seconds", value)
|
|
127
228
|
|
|
229
|
+
@_builtins.property
|
|
230
|
+
@pulumi.getter(name="delegatedAuthAccessors")
|
|
231
|
+
def delegated_auth_accessors(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
232
|
+
"""
|
|
233
|
+
List of headers to allow and pass from the request to the plugin
|
|
234
|
+
"""
|
|
235
|
+
return pulumi.get(self, "delegated_auth_accessors")
|
|
236
|
+
|
|
237
|
+
@delegated_auth_accessors.setter
|
|
238
|
+
def delegated_auth_accessors(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
239
|
+
pulumi.set(self, "delegated_auth_accessors", value)
|
|
240
|
+
|
|
128
241
|
@_builtins.property
|
|
129
242
|
@pulumi.getter
|
|
130
243
|
def description(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
131
244
|
"""
|
|
132
|
-
|
|
245
|
+
Human-friendly description of the mount for the backend.
|
|
133
246
|
"""
|
|
134
247
|
return pulumi.get(self, "description")
|
|
135
248
|
|
|
@@ -150,12 +263,71 @@ class SecretBackendArgs:
|
|
|
150
263
|
def disable_remount(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
151
264
|
pulumi.set(self, "disable_remount", value)
|
|
152
265
|
|
|
266
|
+
@_builtins.property
|
|
267
|
+
@pulumi.getter(name="externalEntropyAccess")
|
|
268
|
+
def external_entropy_access(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
269
|
+
"""
|
|
270
|
+
Enable the secrets engine to access Vault's external entropy source
|
|
271
|
+
"""
|
|
272
|
+
return pulumi.get(self, "external_entropy_access")
|
|
273
|
+
|
|
274
|
+
@external_entropy_access.setter
|
|
275
|
+
def external_entropy_access(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
276
|
+
pulumi.set(self, "external_entropy_access", value)
|
|
277
|
+
|
|
278
|
+
@_builtins.property
|
|
279
|
+
@pulumi.getter(name="forceNoCache")
|
|
280
|
+
def force_no_cache(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
281
|
+
"""
|
|
282
|
+
If set to true, disables caching.
|
|
283
|
+
"""
|
|
284
|
+
return pulumi.get(self, "force_no_cache")
|
|
285
|
+
|
|
286
|
+
@force_no_cache.setter
|
|
287
|
+
def force_no_cache(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
288
|
+
pulumi.set(self, "force_no_cache", value)
|
|
289
|
+
|
|
290
|
+
@_builtins.property
|
|
291
|
+
@pulumi.getter(name="identityTokenKey")
|
|
292
|
+
def identity_token_key(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
293
|
+
"""
|
|
294
|
+
The key to use for signing plugin workload identity tokens
|
|
295
|
+
"""
|
|
296
|
+
return pulumi.get(self, "identity_token_key")
|
|
297
|
+
|
|
298
|
+
@identity_token_key.setter
|
|
299
|
+
def identity_token_key(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
300
|
+
pulumi.set(self, "identity_token_key", value)
|
|
301
|
+
|
|
302
|
+
@_builtins.property
|
|
303
|
+
@pulumi.getter(name="listingVisibility")
|
|
304
|
+
def listing_visibility(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
305
|
+
"""
|
|
306
|
+
Specifies whether to show this mount in the UI-specific listing endpoint
|
|
307
|
+
"""
|
|
308
|
+
return pulumi.get(self, "listing_visibility")
|
|
309
|
+
|
|
310
|
+
@listing_visibility.setter
|
|
311
|
+
def listing_visibility(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
312
|
+
pulumi.set(self, "listing_visibility", value)
|
|
313
|
+
|
|
314
|
+
@_builtins.property
|
|
315
|
+
@pulumi.getter
|
|
316
|
+
def local(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
317
|
+
"""
|
|
318
|
+
Local mount flag that can be explicitly set to true to enforce local mount in HA environment
|
|
319
|
+
"""
|
|
320
|
+
return pulumi.get(self, "local")
|
|
321
|
+
|
|
322
|
+
@local.setter
|
|
323
|
+
def local(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
324
|
+
pulumi.set(self, "local", value)
|
|
325
|
+
|
|
153
326
|
@_builtins.property
|
|
154
327
|
@pulumi.getter(name="maxLeaseTtlSeconds")
|
|
155
328
|
def max_lease_ttl_seconds(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
156
329
|
"""
|
|
157
|
-
|
|
158
|
-
for credentials issued by this backend.
|
|
330
|
+
Maximum possible lease duration for secrets in seconds
|
|
159
331
|
"""
|
|
160
332
|
return pulumi.get(self, "max_lease_ttl_seconds")
|
|
161
333
|
|
|
@@ -178,6 +350,30 @@ class SecretBackendArgs:
|
|
|
178
350
|
def namespace(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
179
351
|
pulumi.set(self, "namespace", value)
|
|
180
352
|
|
|
353
|
+
@_builtins.property
|
|
354
|
+
@pulumi.getter
|
|
355
|
+
def options(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]:
|
|
356
|
+
"""
|
|
357
|
+
Specifies mount type specific options that are passed to the backend
|
|
358
|
+
"""
|
|
359
|
+
return pulumi.get(self, "options")
|
|
360
|
+
|
|
361
|
+
@options.setter
|
|
362
|
+
def options(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]):
|
|
363
|
+
pulumi.set(self, "options", value)
|
|
364
|
+
|
|
365
|
+
@_builtins.property
|
|
366
|
+
@pulumi.getter(name="passthroughRequestHeaders")
|
|
367
|
+
def passthrough_request_headers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
368
|
+
"""
|
|
369
|
+
List of headers to allow and pass from the request to the plugin
|
|
370
|
+
"""
|
|
371
|
+
return pulumi.get(self, "passthrough_request_headers")
|
|
372
|
+
|
|
373
|
+
@passthrough_request_headers.setter
|
|
374
|
+
def passthrough_request_headers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
375
|
+
pulumi.set(self, "passthrough_request_headers", value)
|
|
376
|
+
|
|
181
377
|
@_builtins.property
|
|
182
378
|
@pulumi.getter(name="passwordPolicy")
|
|
183
379
|
def password_policy(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
@@ -203,6 +399,30 @@ class SecretBackendArgs:
|
|
|
203
399
|
def path(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
204
400
|
pulumi.set(self, "path", value)
|
|
205
401
|
|
|
402
|
+
@_builtins.property
|
|
403
|
+
@pulumi.getter(name="pluginVersion")
|
|
404
|
+
def plugin_version(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
405
|
+
"""
|
|
406
|
+
Specifies the semantic version of the plugin to use, e.g. 'v1.0.0'
|
|
407
|
+
"""
|
|
408
|
+
return pulumi.get(self, "plugin_version")
|
|
409
|
+
|
|
410
|
+
@plugin_version.setter
|
|
411
|
+
def plugin_version(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
412
|
+
pulumi.set(self, "plugin_version", value)
|
|
413
|
+
|
|
414
|
+
@_builtins.property
|
|
415
|
+
@pulumi.getter(name="sealWrap")
|
|
416
|
+
def seal_wrap(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
417
|
+
"""
|
|
418
|
+
Enable seal wrapping for the mount, causing values stored by the mount to be wrapped by the seal's encryption capability
|
|
419
|
+
"""
|
|
420
|
+
return pulumi.get(self, "seal_wrap")
|
|
421
|
+
|
|
422
|
+
@seal_wrap.setter
|
|
423
|
+
def seal_wrap(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
424
|
+
pulumi.set(self, "seal_wrap", value)
|
|
425
|
+
|
|
206
426
|
@_builtins.property
|
|
207
427
|
@pulumi.getter(name="usernameTemplate")
|
|
208
428
|
def username_template(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
@@ -232,59 +452,117 @@ class SecretBackendArgs:
|
|
|
232
452
|
@pulumi.input_type
|
|
233
453
|
class _SecretBackendState:
|
|
234
454
|
def __init__(__self__, *,
|
|
455
|
+
accessor: Optional[pulumi.Input[_builtins.str]] = None,
|
|
456
|
+
allowed_managed_keys: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
457
|
+
allowed_response_headers: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
458
|
+
audit_non_hmac_request_keys: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
459
|
+
audit_non_hmac_response_keys: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
235
460
|
connection_uri: Optional[pulumi.Input[_builtins.str]] = None,
|
|
236
461
|
default_lease_ttl_seconds: Optional[pulumi.Input[_builtins.int]] = None,
|
|
462
|
+
delegated_auth_accessors: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
237
463
|
description: Optional[pulumi.Input[_builtins.str]] = None,
|
|
238
464
|
disable_remount: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
465
|
+
external_entropy_access: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
466
|
+
force_no_cache: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
467
|
+
identity_token_key: Optional[pulumi.Input[_builtins.str]] = None,
|
|
468
|
+
listing_visibility: Optional[pulumi.Input[_builtins.str]] = None,
|
|
469
|
+
local: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
239
470
|
max_lease_ttl_seconds: Optional[pulumi.Input[_builtins.int]] = None,
|
|
240
471
|
namespace: Optional[pulumi.Input[_builtins.str]] = None,
|
|
472
|
+
options: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
|
|
473
|
+
passthrough_request_headers: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
241
474
|
password: Optional[pulumi.Input[_builtins.str]] = None,
|
|
242
475
|
password_policy: Optional[pulumi.Input[_builtins.str]] = None,
|
|
243
476
|
path: Optional[pulumi.Input[_builtins.str]] = None,
|
|
477
|
+
plugin_version: Optional[pulumi.Input[_builtins.str]] = None,
|
|
478
|
+
seal_wrap: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
244
479
|
username: Optional[pulumi.Input[_builtins.str]] = None,
|
|
245
480
|
username_template: Optional[pulumi.Input[_builtins.str]] = None,
|
|
246
481
|
verify_connection: Optional[pulumi.Input[_builtins.bool]] = None):
|
|
247
482
|
"""
|
|
248
483
|
Input properties used for looking up and filtering SecretBackend resources.
|
|
484
|
+
:param pulumi.Input[_builtins.str] accessor: Accessor of the mount
|
|
485
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] allowed_managed_keys: List of managed key registry entry names that the mount in question is allowed to access
|
|
486
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] allowed_response_headers: List of headers to allow and pass from the request to the plugin
|
|
487
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] audit_non_hmac_request_keys: Specifies the list of keys that will not be HMAC'd by audit devices in the request data object.
|
|
488
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] audit_non_hmac_response_keys: Specifies the list of keys that will not be HMAC'd by audit devices in the response data object.
|
|
249
489
|
:param pulumi.Input[_builtins.str] connection_uri: Specifies the RabbitMQ connection URI.
|
|
250
|
-
:param pulumi.Input[_builtins.int] default_lease_ttl_seconds:
|
|
251
|
-
|
|
252
|
-
:param pulumi.Input[_builtins.str] description:
|
|
490
|
+
:param pulumi.Input[_builtins.int] default_lease_ttl_seconds: Default lease duration for secrets in seconds
|
|
491
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] delegated_auth_accessors: List of headers to allow and pass from the request to the plugin
|
|
492
|
+
:param pulumi.Input[_builtins.str] description: Human-friendly description of the mount for the backend.
|
|
253
493
|
:param pulumi.Input[_builtins.bool] disable_remount: If set, opts out of mount migration on path updates.
|
|
254
494
|
See here for more info on [Mount Migration](https://www.vaultproject.io/docs/concepts/mount-migration)
|
|
255
|
-
:param pulumi.Input[_builtins.
|
|
256
|
-
|
|
495
|
+
:param pulumi.Input[_builtins.bool] external_entropy_access: Enable the secrets engine to access Vault's external entropy source
|
|
496
|
+
:param pulumi.Input[_builtins.bool] force_no_cache: If set to true, disables caching.
|
|
497
|
+
:param pulumi.Input[_builtins.str] identity_token_key: The key to use for signing plugin workload identity tokens
|
|
498
|
+
:param pulumi.Input[_builtins.str] listing_visibility: Specifies whether to show this mount in the UI-specific listing endpoint
|
|
499
|
+
:param pulumi.Input[_builtins.bool] local: Local mount flag that can be explicitly set to true to enforce local mount in HA environment
|
|
500
|
+
:param pulumi.Input[_builtins.int] max_lease_ttl_seconds: Maximum possible lease duration for secrets in seconds
|
|
257
501
|
:param pulumi.Input[_builtins.str] namespace: The namespace to provision the resource in.
|
|
258
502
|
The value should not contain leading or trailing forward slashes.
|
|
259
503
|
The `namespace` is always relative to the provider's configured [namespace](https://www.terraform.io/docs/providers/vault/index.html#namespace).
|
|
260
504
|
*Available only for Vault Enterprise*.
|
|
505
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] options: Specifies mount type specific options that are passed to the backend
|
|
506
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] passthrough_request_headers: List of headers to allow and pass from the request to the plugin
|
|
261
507
|
:param pulumi.Input[_builtins.str] password: Specifies the RabbitMQ management administrator password.
|
|
262
508
|
:param pulumi.Input[_builtins.str] password_policy: Specifies a password policy to use when creating dynamic credentials. Defaults to generating an alphanumeric password if not set.
|
|
263
509
|
:param pulumi.Input[_builtins.str] path: The unique path this backend should be mounted at. Must
|
|
264
510
|
not begin or end with a `/`. Defaults to `rabbitmq`.
|
|
511
|
+
:param pulumi.Input[_builtins.str] plugin_version: Specifies the semantic version of the plugin to use, e.g. 'v1.0.0'
|
|
512
|
+
:param pulumi.Input[_builtins.bool] seal_wrap: Enable seal wrapping for the mount, causing values stored by the mount to be wrapped by the seal's encryption capability
|
|
265
513
|
:param pulumi.Input[_builtins.str] username: Specifies the RabbitMQ management administrator username.
|
|
266
514
|
:param pulumi.Input[_builtins.str] username_template: Template describing how dynamic usernames are generated.
|
|
267
515
|
:param pulumi.Input[_builtins.bool] verify_connection: Specifies whether to verify connection URI, username, and password.
|
|
268
516
|
Defaults to `true`.
|
|
269
517
|
"""
|
|
518
|
+
if accessor is not None:
|
|
519
|
+
pulumi.set(__self__, "accessor", accessor)
|
|
520
|
+
if allowed_managed_keys is not None:
|
|
521
|
+
pulumi.set(__self__, "allowed_managed_keys", allowed_managed_keys)
|
|
522
|
+
if allowed_response_headers is not None:
|
|
523
|
+
pulumi.set(__self__, "allowed_response_headers", allowed_response_headers)
|
|
524
|
+
if audit_non_hmac_request_keys is not None:
|
|
525
|
+
pulumi.set(__self__, "audit_non_hmac_request_keys", audit_non_hmac_request_keys)
|
|
526
|
+
if audit_non_hmac_response_keys is not None:
|
|
527
|
+
pulumi.set(__self__, "audit_non_hmac_response_keys", audit_non_hmac_response_keys)
|
|
270
528
|
if connection_uri is not None:
|
|
271
529
|
pulumi.set(__self__, "connection_uri", connection_uri)
|
|
272
530
|
if default_lease_ttl_seconds is not None:
|
|
273
531
|
pulumi.set(__self__, "default_lease_ttl_seconds", default_lease_ttl_seconds)
|
|
532
|
+
if delegated_auth_accessors is not None:
|
|
533
|
+
pulumi.set(__self__, "delegated_auth_accessors", delegated_auth_accessors)
|
|
274
534
|
if description is not None:
|
|
275
535
|
pulumi.set(__self__, "description", description)
|
|
276
536
|
if disable_remount is not None:
|
|
277
537
|
pulumi.set(__self__, "disable_remount", disable_remount)
|
|
538
|
+
if external_entropy_access is not None:
|
|
539
|
+
pulumi.set(__self__, "external_entropy_access", external_entropy_access)
|
|
540
|
+
if force_no_cache is not None:
|
|
541
|
+
pulumi.set(__self__, "force_no_cache", force_no_cache)
|
|
542
|
+
if identity_token_key is not None:
|
|
543
|
+
pulumi.set(__self__, "identity_token_key", identity_token_key)
|
|
544
|
+
if listing_visibility is not None:
|
|
545
|
+
pulumi.set(__self__, "listing_visibility", listing_visibility)
|
|
546
|
+
if local is not None:
|
|
547
|
+
pulumi.set(__self__, "local", local)
|
|
278
548
|
if max_lease_ttl_seconds is not None:
|
|
279
549
|
pulumi.set(__self__, "max_lease_ttl_seconds", max_lease_ttl_seconds)
|
|
280
550
|
if namespace is not None:
|
|
281
551
|
pulumi.set(__self__, "namespace", namespace)
|
|
552
|
+
if options is not None:
|
|
553
|
+
pulumi.set(__self__, "options", options)
|
|
554
|
+
if passthrough_request_headers is not None:
|
|
555
|
+
pulumi.set(__self__, "passthrough_request_headers", passthrough_request_headers)
|
|
282
556
|
if password is not None:
|
|
283
557
|
pulumi.set(__self__, "password", password)
|
|
284
558
|
if password_policy is not None:
|
|
285
559
|
pulumi.set(__self__, "password_policy", password_policy)
|
|
286
560
|
if path is not None:
|
|
287
561
|
pulumi.set(__self__, "path", path)
|
|
562
|
+
if plugin_version is not None:
|
|
563
|
+
pulumi.set(__self__, "plugin_version", plugin_version)
|
|
564
|
+
if seal_wrap is not None:
|
|
565
|
+
pulumi.set(__self__, "seal_wrap", seal_wrap)
|
|
288
566
|
if username is not None:
|
|
289
567
|
pulumi.set(__self__, "username", username)
|
|
290
568
|
if username_template is not None:
|
|
@@ -292,6 +570,66 @@ class _SecretBackendState:
|
|
|
292
570
|
if verify_connection is not None:
|
|
293
571
|
pulumi.set(__self__, "verify_connection", verify_connection)
|
|
294
572
|
|
|
573
|
+
@_builtins.property
|
|
574
|
+
@pulumi.getter
|
|
575
|
+
def accessor(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
576
|
+
"""
|
|
577
|
+
Accessor of the mount
|
|
578
|
+
"""
|
|
579
|
+
return pulumi.get(self, "accessor")
|
|
580
|
+
|
|
581
|
+
@accessor.setter
|
|
582
|
+
def accessor(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
583
|
+
pulumi.set(self, "accessor", value)
|
|
584
|
+
|
|
585
|
+
@_builtins.property
|
|
586
|
+
@pulumi.getter(name="allowedManagedKeys")
|
|
587
|
+
def allowed_managed_keys(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
588
|
+
"""
|
|
589
|
+
List of managed key registry entry names that the mount in question is allowed to access
|
|
590
|
+
"""
|
|
591
|
+
return pulumi.get(self, "allowed_managed_keys")
|
|
592
|
+
|
|
593
|
+
@allowed_managed_keys.setter
|
|
594
|
+
def allowed_managed_keys(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
595
|
+
pulumi.set(self, "allowed_managed_keys", value)
|
|
596
|
+
|
|
597
|
+
@_builtins.property
|
|
598
|
+
@pulumi.getter(name="allowedResponseHeaders")
|
|
599
|
+
def allowed_response_headers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
600
|
+
"""
|
|
601
|
+
List of headers to allow and pass from the request to the plugin
|
|
602
|
+
"""
|
|
603
|
+
return pulumi.get(self, "allowed_response_headers")
|
|
604
|
+
|
|
605
|
+
@allowed_response_headers.setter
|
|
606
|
+
def allowed_response_headers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
607
|
+
pulumi.set(self, "allowed_response_headers", value)
|
|
608
|
+
|
|
609
|
+
@_builtins.property
|
|
610
|
+
@pulumi.getter(name="auditNonHmacRequestKeys")
|
|
611
|
+
def audit_non_hmac_request_keys(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
612
|
+
"""
|
|
613
|
+
Specifies the list of keys that will not be HMAC'd by audit devices in the request data object.
|
|
614
|
+
"""
|
|
615
|
+
return pulumi.get(self, "audit_non_hmac_request_keys")
|
|
616
|
+
|
|
617
|
+
@audit_non_hmac_request_keys.setter
|
|
618
|
+
def audit_non_hmac_request_keys(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
619
|
+
pulumi.set(self, "audit_non_hmac_request_keys", value)
|
|
620
|
+
|
|
621
|
+
@_builtins.property
|
|
622
|
+
@pulumi.getter(name="auditNonHmacResponseKeys")
|
|
623
|
+
def audit_non_hmac_response_keys(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
624
|
+
"""
|
|
625
|
+
Specifies the list of keys that will not be HMAC'd by audit devices in the response data object.
|
|
626
|
+
"""
|
|
627
|
+
return pulumi.get(self, "audit_non_hmac_response_keys")
|
|
628
|
+
|
|
629
|
+
@audit_non_hmac_response_keys.setter
|
|
630
|
+
def audit_non_hmac_response_keys(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
631
|
+
pulumi.set(self, "audit_non_hmac_response_keys", value)
|
|
632
|
+
|
|
295
633
|
@_builtins.property
|
|
296
634
|
@pulumi.getter(name="connectionUri")
|
|
297
635
|
def connection_uri(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
@@ -308,8 +646,7 @@ class _SecretBackendState:
|
|
|
308
646
|
@pulumi.getter(name="defaultLeaseTtlSeconds")
|
|
309
647
|
def default_lease_ttl_seconds(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
310
648
|
"""
|
|
311
|
-
|
|
312
|
-
issued by this backend.
|
|
649
|
+
Default lease duration for secrets in seconds
|
|
313
650
|
"""
|
|
314
651
|
return pulumi.get(self, "default_lease_ttl_seconds")
|
|
315
652
|
|
|
@@ -317,11 +654,23 @@ class _SecretBackendState:
|
|
|
317
654
|
def default_lease_ttl_seconds(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
318
655
|
pulumi.set(self, "default_lease_ttl_seconds", value)
|
|
319
656
|
|
|
657
|
+
@_builtins.property
|
|
658
|
+
@pulumi.getter(name="delegatedAuthAccessors")
|
|
659
|
+
def delegated_auth_accessors(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
660
|
+
"""
|
|
661
|
+
List of headers to allow and pass from the request to the plugin
|
|
662
|
+
"""
|
|
663
|
+
return pulumi.get(self, "delegated_auth_accessors")
|
|
664
|
+
|
|
665
|
+
@delegated_auth_accessors.setter
|
|
666
|
+
def delegated_auth_accessors(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
667
|
+
pulumi.set(self, "delegated_auth_accessors", value)
|
|
668
|
+
|
|
320
669
|
@_builtins.property
|
|
321
670
|
@pulumi.getter
|
|
322
671
|
def description(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
323
672
|
"""
|
|
324
|
-
|
|
673
|
+
Human-friendly description of the mount for the backend.
|
|
325
674
|
"""
|
|
326
675
|
return pulumi.get(self, "description")
|
|
327
676
|
|
|
@@ -342,12 +691,71 @@ class _SecretBackendState:
|
|
|
342
691
|
def disable_remount(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
343
692
|
pulumi.set(self, "disable_remount", value)
|
|
344
693
|
|
|
694
|
+
@_builtins.property
|
|
695
|
+
@pulumi.getter(name="externalEntropyAccess")
|
|
696
|
+
def external_entropy_access(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
697
|
+
"""
|
|
698
|
+
Enable the secrets engine to access Vault's external entropy source
|
|
699
|
+
"""
|
|
700
|
+
return pulumi.get(self, "external_entropy_access")
|
|
701
|
+
|
|
702
|
+
@external_entropy_access.setter
|
|
703
|
+
def external_entropy_access(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
704
|
+
pulumi.set(self, "external_entropy_access", value)
|
|
705
|
+
|
|
706
|
+
@_builtins.property
|
|
707
|
+
@pulumi.getter(name="forceNoCache")
|
|
708
|
+
def force_no_cache(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
709
|
+
"""
|
|
710
|
+
If set to true, disables caching.
|
|
711
|
+
"""
|
|
712
|
+
return pulumi.get(self, "force_no_cache")
|
|
713
|
+
|
|
714
|
+
@force_no_cache.setter
|
|
715
|
+
def force_no_cache(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
716
|
+
pulumi.set(self, "force_no_cache", value)
|
|
717
|
+
|
|
718
|
+
@_builtins.property
|
|
719
|
+
@pulumi.getter(name="identityTokenKey")
|
|
720
|
+
def identity_token_key(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
721
|
+
"""
|
|
722
|
+
The key to use for signing plugin workload identity tokens
|
|
723
|
+
"""
|
|
724
|
+
return pulumi.get(self, "identity_token_key")
|
|
725
|
+
|
|
726
|
+
@identity_token_key.setter
|
|
727
|
+
def identity_token_key(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
728
|
+
pulumi.set(self, "identity_token_key", value)
|
|
729
|
+
|
|
730
|
+
@_builtins.property
|
|
731
|
+
@pulumi.getter(name="listingVisibility")
|
|
732
|
+
def listing_visibility(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
733
|
+
"""
|
|
734
|
+
Specifies whether to show this mount in the UI-specific listing endpoint
|
|
735
|
+
"""
|
|
736
|
+
return pulumi.get(self, "listing_visibility")
|
|
737
|
+
|
|
738
|
+
@listing_visibility.setter
|
|
739
|
+
def listing_visibility(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
740
|
+
pulumi.set(self, "listing_visibility", value)
|
|
741
|
+
|
|
742
|
+
@_builtins.property
|
|
743
|
+
@pulumi.getter
|
|
744
|
+
def local(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
745
|
+
"""
|
|
746
|
+
Local mount flag that can be explicitly set to true to enforce local mount in HA environment
|
|
747
|
+
"""
|
|
748
|
+
return pulumi.get(self, "local")
|
|
749
|
+
|
|
750
|
+
@local.setter
|
|
751
|
+
def local(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
752
|
+
pulumi.set(self, "local", value)
|
|
753
|
+
|
|
345
754
|
@_builtins.property
|
|
346
755
|
@pulumi.getter(name="maxLeaseTtlSeconds")
|
|
347
756
|
def max_lease_ttl_seconds(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
348
757
|
"""
|
|
349
|
-
|
|
350
|
-
for credentials issued by this backend.
|
|
758
|
+
Maximum possible lease duration for secrets in seconds
|
|
351
759
|
"""
|
|
352
760
|
return pulumi.get(self, "max_lease_ttl_seconds")
|
|
353
761
|
|
|
@@ -370,6 +778,30 @@ class _SecretBackendState:
|
|
|
370
778
|
def namespace(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
371
779
|
pulumi.set(self, "namespace", value)
|
|
372
780
|
|
|
781
|
+
@_builtins.property
|
|
782
|
+
@pulumi.getter
|
|
783
|
+
def options(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]:
|
|
784
|
+
"""
|
|
785
|
+
Specifies mount type specific options that are passed to the backend
|
|
786
|
+
"""
|
|
787
|
+
return pulumi.get(self, "options")
|
|
788
|
+
|
|
789
|
+
@options.setter
|
|
790
|
+
def options(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]):
|
|
791
|
+
pulumi.set(self, "options", value)
|
|
792
|
+
|
|
793
|
+
@_builtins.property
|
|
794
|
+
@pulumi.getter(name="passthroughRequestHeaders")
|
|
795
|
+
def passthrough_request_headers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
796
|
+
"""
|
|
797
|
+
List of headers to allow and pass from the request to the plugin
|
|
798
|
+
"""
|
|
799
|
+
return pulumi.get(self, "passthrough_request_headers")
|
|
800
|
+
|
|
801
|
+
@passthrough_request_headers.setter
|
|
802
|
+
def passthrough_request_headers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
803
|
+
pulumi.set(self, "passthrough_request_headers", value)
|
|
804
|
+
|
|
373
805
|
@_builtins.property
|
|
374
806
|
@pulumi.getter
|
|
375
807
|
def password(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
@@ -407,6 +839,30 @@ class _SecretBackendState:
|
|
|
407
839
|
def path(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
408
840
|
pulumi.set(self, "path", value)
|
|
409
841
|
|
|
842
|
+
@_builtins.property
|
|
843
|
+
@pulumi.getter(name="pluginVersion")
|
|
844
|
+
def plugin_version(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
845
|
+
"""
|
|
846
|
+
Specifies the semantic version of the plugin to use, e.g. 'v1.0.0'
|
|
847
|
+
"""
|
|
848
|
+
return pulumi.get(self, "plugin_version")
|
|
849
|
+
|
|
850
|
+
@plugin_version.setter
|
|
851
|
+
def plugin_version(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
852
|
+
pulumi.set(self, "plugin_version", value)
|
|
853
|
+
|
|
854
|
+
@_builtins.property
|
|
855
|
+
@pulumi.getter(name="sealWrap")
|
|
856
|
+
def seal_wrap(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
857
|
+
"""
|
|
858
|
+
Enable seal wrapping for the mount, causing values stored by the mount to be wrapped by the seal's encryption capability
|
|
859
|
+
"""
|
|
860
|
+
return pulumi.get(self, "seal_wrap")
|
|
861
|
+
|
|
862
|
+
@seal_wrap.setter
|
|
863
|
+
def seal_wrap(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
864
|
+
pulumi.set(self, "seal_wrap", value)
|
|
865
|
+
|
|
410
866
|
@_builtins.property
|
|
411
867
|
@pulumi.getter
|
|
412
868
|
def username(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
@@ -451,15 +907,29 @@ class SecretBackend(pulumi.CustomResource):
|
|
|
451
907
|
def __init__(__self__,
|
|
452
908
|
resource_name: str,
|
|
453
909
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
910
|
+
allowed_managed_keys: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
911
|
+
allowed_response_headers: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
912
|
+
audit_non_hmac_request_keys: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
913
|
+
audit_non_hmac_response_keys: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
454
914
|
connection_uri: Optional[pulumi.Input[_builtins.str]] = None,
|
|
455
915
|
default_lease_ttl_seconds: Optional[pulumi.Input[_builtins.int]] = None,
|
|
916
|
+
delegated_auth_accessors: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
456
917
|
description: Optional[pulumi.Input[_builtins.str]] = None,
|
|
457
918
|
disable_remount: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
919
|
+
external_entropy_access: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
920
|
+
force_no_cache: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
921
|
+
identity_token_key: Optional[pulumi.Input[_builtins.str]] = None,
|
|
922
|
+
listing_visibility: Optional[pulumi.Input[_builtins.str]] = None,
|
|
923
|
+
local: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
458
924
|
max_lease_ttl_seconds: Optional[pulumi.Input[_builtins.int]] = None,
|
|
459
925
|
namespace: Optional[pulumi.Input[_builtins.str]] = None,
|
|
926
|
+
options: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
|
|
927
|
+
passthrough_request_headers: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
460
928
|
password: Optional[pulumi.Input[_builtins.str]] = None,
|
|
461
929
|
password_policy: Optional[pulumi.Input[_builtins.str]] = None,
|
|
462
930
|
path: Optional[pulumi.Input[_builtins.str]] = None,
|
|
931
|
+
plugin_version: Optional[pulumi.Input[_builtins.str]] = None,
|
|
932
|
+
seal_wrap: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
463
933
|
username: Optional[pulumi.Input[_builtins.str]] = None,
|
|
464
934
|
username_template: Optional[pulumi.Input[_builtins.str]] = None,
|
|
465
935
|
verify_connection: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
@@ -487,22 +957,34 @@ class SecretBackend(pulumi.CustomResource):
|
|
|
487
957
|
|
|
488
958
|
:param str resource_name: The name of the resource.
|
|
489
959
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
960
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] allowed_managed_keys: List of managed key registry entry names that the mount in question is allowed to access
|
|
961
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] allowed_response_headers: List of headers to allow and pass from the request to the plugin
|
|
962
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] audit_non_hmac_request_keys: Specifies the list of keys that will not be HMAC'd by audit devices in the request data object.
|
|
963
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] audit_non_hmac_response_keys: Specifies the list of keys that will not be HMAC'd by audit devices in the response data object.
|
|
490
964
|
:param pulumi.Input[_builtins.str] connection_uri: Specifies the RabbitMQ connection URI.
|
|
491
|
-
:param pulumi.Input[_builtins.int] default_lease_ttl_seconds:
|
|
492
|
-
|
|
493
|
-
:param pulumi.Input[_builtins.str] description:
|
|
965
|
+
:param pulumi.Input[_builtins.int] default_lease_ttl_seconds: Default lease duration for secrets in seconds
|
|
966
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] delegated_auth_accessors: List of headers to allow and pass from the request to the plugin
|
|
967
|
+
:param pulumi.Input[_builtins.str] description: Human-friendly description of the mount for the backend.
|
|
494
968
|
:param pulumi.Input[_builtins.bool] disable_remount: If set, opts out of mount migration on path updates.
|
|
495
969
|
See here for more info on [Mount Migration](https://www.vaultproject.io/docs/concepts/mount-migration)
|
|
496
|
-
:param pulumi.Input[_builtins.
|
|
497
|
-
|
|
970
|
+
:param pulumi.Input[_builtins.bool] external_entropy_access: Enable the secrets engine to access Vault's external entropy source
|
|
971
|
+
:param pulumi.Input[_builtins.bool] force_no_cache: If set to true, disables caching.
|
|
972
|
+
:param pulumi.Input[_builtins.str] identity_token_key: The key to use for signing plugin workload identity tokens
|
|
973
|
+
:param pulumi.Input[_builtins.str] listing_visibility: Specifies whether to show this mount in the UI-specific listing endpoint
|
|
974
|
+
:param pulumi.Input[_builtins.bool] local: Local mount flag that can be explicitly set to true to enforce local mount in HA environment
|
|
975
|
+
:param pulumi.Input[_builtins.int] max_lease_ttl_seconds: Maximum possible lease duration for secrets in seconds
|
|
498
976
|
:param pulumi.Input[_builtins.str] namespace: The namespace to provision the resource in.
|
|
499
977
|
The value should not contain leading or trailing forward slashes.
|
|
500
978
|
The `namespace` is always relative to the provider's configured [namespace](https://www.terraform.io/docs/providers/vault/index.html#namespace).
|
|
501
979
|
*Available only for Vault Enterprise*.
|
|
980
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] options: Specifies mount type specific options that are passed to the backend
|
|
981
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] passthrough_request_headers: List of headers to allow and pass from the request to the plugin
|
|
502
982
|
:param pulumi.Input[_builtins.str] password: Specifies the RabbitMQ management administrator password.
|
|
503
983
|
:param pulumi.Input[_builtins.str] password_policy: Specifies a password policy to use when creating dynamic credentials. Defaults to generating an alphanumeric password if not set.
|
|
504
984
|
:param pulumi.Input[_builtins.str] path: The unique path this backend should be mounted at. Must
|
|
505
985
|
not begin or end with a `/`. Defaults to `rabbitmq`.
|
|
986
|
+
:param pulumi.Input[_builtins.str] plugin_version: Specifies the semantic version of the plugin to use, e.g. 'v1.0.0'
|
|
987
|
+
:param pulumi.Input[_builtins.bool] seal_wrap: Enable seal wrapping for the mount, causing values stored by the mount to be wrapped by the seal's encryption capability
|
|
506
988
|
:param pulumi.Input[_builtins.str] username: Specifies the RabbitMQ management administrator username.
|
|
507
989
|
:param pulumi.Input[_builtins.str] username_template: Template describing how dynamic usernames are generated.
|
|
508
990
|
:param pulumi.Input[_builtins.bool] verify_connection: Specifies whether to verify connection URI, username, and password.
|
|
@@ -550,15 +1032,29 @@ class SecretBackend(pulumi.CustomResource):
|
|
|
550
1032
|
def _internal_init(__self__,
|
|
551
1033
|
resource_name: str,
|
|
552
1034
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
1035
|
+
allowed_managed_keys: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1036
|
+
allowed_response_headers: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1037
|
+
audit_non_hmac_request_keys: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1038
|
+
audit_non_hmac_response_keys: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
553
1039
|
connection_uri: Optional[pulumi.Input[_builtins.str]] = None,
|
|
554
1040
|
default_lease_ttl_seconds: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1041
|
+
delegated_auth_accessors: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
555
1042
|
description: Optional[pulumi.Input[_builtins.str]] = None,
|
|
556
1043
|
disable_remount: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1044
|
+
external_entropy_access: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1045
|
+
force_no_cache: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1046
|
+
identity_token_key: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1047
|
+
listing_visibility: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1048
|
+
local: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
557
1049
|
max_lease_ttl_seconds: Optional[pulumi.Input[_builtins.int]] = None,
|
|
558
1050
|
namespace: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1051
|
+
options: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
|
|
1052
|
+
passthrough_request_headers: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
559
1053
|
password: Optional[pulumi.Input[_builtins.str]] = None,
|
|
560
1054
|
password_policy: Optional[pulumi.Input[_builtins.str]] = None,
|
|
561
1055
|
path: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1056
|
+
plugin_version: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1057
|
+
seal_wrap: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
562
1058
|
username: Optional[pulumi.Input[_builtins.str]] = None,
|
|
563
1059
|
username_template: Optional[pulumi.Input[_builtins.str]] = None,
|
|
564
1060
|
verify_connection: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
@@ -571,24 +1067,39 @@ class SecretBackend(pulumi.CustomResource):
|
|
|
571
1067
|
raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
|
|
572
1068
|
__props__ = SecretBackendArgs.__new__(SecretBackendArgs)
|
|
573
1069
|
|
|
1070
|
+
__props__.__dict__["allowed_managed_keys"] = allowed_managed_keys
|
|
1071
|
+
__props__.__dict__["allowed_response_headers"] = allowed_response_headers
|
|
1072
|
+
__props__.__dict__["audit_non_hmac_request_keys"] = audit_non_hmac_request_keys
|
|
1073
|
+
__props__.__dict__["audit_non_hmac_response_keys"] = audit_non_hmac_response_keys
|
|
574
1074
|
if connection_uri is None and not opts.urn:
|
|
575
1075
|
raise TypeError("Missing required property 'connection_uri'")
|
|
576
1076
|
__props__.__dict__["connection_uri"] = connection_uri
|
|
577
1077
|
__props__.__dict__["default_lease_ttl_seconds"] = default_lease_ttl_seconds
|
|
1078
|
+
__props__.__dict__["delegated_auth_accessors"] = delegated_auth_accessors
|
|
578
1079
|
__props__.__dict__["description"] = description
|
|
579
1080
|
__props__.__dict__["disable_remount"] = disable_remount
|
|
1081
|
+
__props__.__dict__["external_entropy_access"] = external_entropy_access
|
|
1082
|
+
__props__.__dict__["force_no_cache"] = force_no_cache
|
|
1083
|
+
__props__.__dict__["identity_token_key"] = identity_token_key
|
|
1084
|
+
__props__.__dict__["listing_visibility"] = listing_visibility
|
|
1085
|
+
__props__.__dict__["local"] = local
|
|
580
1086
|
__props__.__dict__["max_lease_ttl_seconds"] = max_lease_ttl_seconds
|
|
581
1087
|
__props__.__dict__["namespace"] = namespace
|
|
1088
|
+
__props__.__dict__["options"] = options
|
|
1089
|
+
__props__.__dict__["passthrough_request_headers"] = passthrough_request_headers
|
|
582
1090
|
if password is None and not opts.urn:
|
|
583
1091
|
raise TypeError("Missing required property 'password'")
|
|
584
1092
|
__props__.__dict__["password"] = None if password is None else pulumi.Output.secret(password)
|
|
585
1093
|
__props__.__dict__["password_policy"] = password_policy
|
|
586
1094
|
__props__.__dict__["path"] = path
|
|
1095
|
+
__props__.__dict__["plugin_version"] = plugin_version
|
|
1096
|
+
__props__.__dict__["seal_wrap"] = seal_wrap
|
|
587
1097
|
if username is None and not opts.urn:
|
|
588
1098
|
raise TypeError("Missing required property 'username'")
|
|
589
1099
|
__props__.__dict__["username"] = None if username is None else pulumi.Output.secret(username)
|
|
590
1100
|
__props__.__dict__["username_template"] = username_template
|
|
591
1101
|
__props__.__dict__["verify_connection"] = verify_connection
|
|
1102
|
+
__props__.__dict__["accessor"] = None
|
|
592
1103
|
secret_opts = pulumi.ResourceOptions(additional_secret_outputs=["password", "username"])
|
|
593
1104
|
opts = pulumi.ResourceOptions.merge(opts, secret_opts)
|
|
594
1105
|
super(SecretBackend, __self__).__init__(
|
|
@@ -601,15 +1112,30 @@ class SecretBackend(pulumi.CustomResource):
|
|
|
601
1112
|
def get(resource_name: str,
|
|
602
1113
|
id: pulumi.Input[str],
|
|
603
1114
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
1115
|
+
accessor: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1116
|
+
allowed_managed_keys: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1117
|
+
allowed_response_headers: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1118
|
+
audit_non_hmac_request_keys: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1119
|
+
audit_non_hmac_response_keys: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
604
1120
|
connection_uri: Optional[pulumi.Input[_builtins.str]] = None,
|
|
605
1121
|
default_lease_ttl_seconds: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1122
|
+
delegated_auth_accessors: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
606
1123
|
description: Optional[pulumi.Input[_builtins.str]] = None,
|
|
607
1124
|
disable_remount: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1125
|
+
external_entropy_access: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1126
|
+
force_no_cache: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1127
|
+
identity_token_key: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1128
|
+
listing_visibility: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1129
|
+
local: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
608
1130
|
max_lease_ttl_seconds: Optional[pulumi.Input[_builtins.int]] = None,
|
|
609
1131
|
namespace: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1132
|
+
options: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
|
|
1133
|
+
passthrough_request_headers: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
610
1134
|
password: Optional[pulumi.Input[_builtins.str]] = None,
|
|
611
1135
|
password_policy: Optional[pulumi.Input[_builtins.str]] = None,
|
|
612
1136
|
path: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1137
|
+
plugin_version: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1138
|
+
seal_wrap: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
613
1139
|
username: Optional[pulumi.Input[_builtins.str]] = None,
|
|
614
1140
|
username_template: Optional[pulumi.Input[_builtins.str]] = None,
|
|
615
1141
|
verify_connection: Optional[pulumi.Input[_builtins.bool]] = None) -> 'SecretBackend':
|
|
@@ -620,22 +1146,35 @@ class SecretBackend(pulumi.CustomResource):
|
|
|
620
1146
|
:param str resource_name: The unique name of the resulting resource.
|
|
621
1147
|
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
|
|
622
1148
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
1149
|
+
:param pulumi.Input[_builtins.str] accessor: Accessor of the mount
|
|
1150
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] allowed_managed_keys: List of managed key registry entry names that the mount in question is allowed to access
|
|
1151
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] allowed_response_headers: List of headers to allow and pass from the request to the plugin
|
|
1152
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] audit_non_hmac_request_keys: Specifies the list of keys that will not be HMAC'd by audit devices in the request data object.
|
|
1153
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] audit_non_hmac_response_keys: Specifies the list of keys that will not be HMAC'd by audit devices in the response data object.
|
|
623
1154
|
:param pulumi.Input[_builtins.str] connection_uri: Specifies the RabbitMQ connection URI.
|
|
624
|
-
:param pulumi.Input[_builtins.int] default_lease_ttl_seconds:
|
|
625
|
-
|
|
626
|
-
:param pulumi.Input[_builtins.str] description:
|
|
1155
|
+
:param pulumi.Input[_builtins.int] default_lease_ttl_seconds: Default lease duration for secrets in seconds
|
|
1156
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] delegated_auth_accessors: List of headers to allow and pass from the request to the plugin
|
|
1157
|
+
:param pulumi.Input[_builtins.str] description: Human-friendly description of the mount for the backend.
|
|
627
1158
|
:param pulumi.Input[_builtins.bool] disable_remount: If set, opts out of mount migration on path updates.
|
|
628
1159
|
See here for more info on [Mount Migration](https://www.vaultproject.io/docs/concepts/mount-migration)
|
|
629
|
-
:param pulumi.Input[_builtins.
|
|
630
|
-
|
|
1160
|
+
:param pulumi.Input[_builtins.bool] external_entropy_access: Enable the secrets engine to access Vault's external entropy source
|
|
1161
|
+
:param pulumi.Input[_builtins.bool] force_no_cache: If set to true, disables caching.
|
|
1162
|
+
:param pulumi.Input[_builtins.str] identity_token_key: The key to use for signing plugin workload identity tokens
|
|
1163
|
+
:param pulumi.Input[_builtins.str] listing_visibility: Specifies whether to show this mount in the UI-specific listing endpoint
|
|
1164
|
+
:param pulumi.Input[_builtins.bool] local: Local mount flag that can be explicitly set to true to enforce local mount in HA environment
|
|
1165
|
+
:param pulumi.Input[_builtins.int] max_lease_ttl_seconds: Maximum possible lease duration for secrets in seconds
|
|
631
1166
|
:param pulumi.Input[_builtins.str] namespace: The namespace to provision the resource in.
|
|
632
1167
|
The value should not contain leading or trailing forward slashes.
|
|
633
1168
|
The `namespace` is always relative to the provider's configured [namespace](https://www.terraform.io/docs/providers/vault/index.html#namespace).
|
|
634
1169
|
*Available only for Vault Enterprise*.
|
|
1170
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] options: Specifies mount type specific options that are passed to the backend
|
|
1171
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] passthrough_request_headers: List of headers to allow and pass from the request to the plugin
|
|
635
1172
|
:param pulumi.Input[_builtins.str] password: Specifies the RabbitMQ management administrator password.
|
|
636
1173
|
:param pulumi.Input[_builtins.str] password_policy: Specifies a password policy to use when creating dynamic credentials. Defaults to generating an alphanumeric password if not set.
|
|
637
1174
|
:param pulumi.Input[_builtins.str] path: The unique path this backend should be mounted at. Must
|
|
638
1175
|
not begin or end with a `/`. Defaults to `rabbitmq`.
|
|
1176
|
+
:param pulumi.Input[_builtins.str] plugin_version: Specifies the semantic version of the plugin to use, e.g. 'v1.0.0'
|
|
1177
|
+
:param pulumi.Input[_builtins.bool] seal_wrap: Enable seal wrapping for the mount, causing values stored by the mount to be wrapped by the seal's encryption capability
|
|
639
1178
|
:param pulumi.Input[_builtins.str] username: Specifies the RabbitMQ management administrator username.
|
|
640
1179
|
:param pulumi.Input[_builtins.str] username_template: Template describing how dynamic usernames are generated.
|
|
641
1180
|
:param pulumi.Input[_builtins.bool] verify_connection: Specifies whether to verify connection URI, username, and password.
|
|
@@ -645,20 +1184,75 @@ class SecretBackend(pulumi.CustomResource):
|
|
|
645
1184
|
|
|
646
1185
|
__props__ = _SecretBackendState.__new__(_SecretBackendState)
|
|
647
1186
|
|
|
1187
|
+
__props__.__dict__["accessor"] = accessor
|
|
1188
|
+
__props__.__dict__["allowed_managed_keys"] = allowed_managed_keys
|
|
1189
|
+
__props__.__dict__["allowed_response_headers"] = allowed_response_headers
|
|
1190
|
+
__props__.__dict__["audit_non_hmac_request_keys"] = audit_non_hmac_request_keys
|
|
1191
|
+
__props__.__dict__["audit_non_hmac_response_keys"] = audit_non_hmac_response_keys
|
|
648
1192
|
__props__.__dict__["connection_uri"] = connection_uri
|
|
649
1193
|
__props__.__dict__["default_lease_ttl_seconds"] = default_lease_ttl_seconds
|
|
1194
|
+
__props__.__dict__["delegated_auth_accessors"] = delegated_auth_accessors
|
|
650
1195
|
__props__.__dict__["description"] = description
|
|
651
1196
|
__props__.__dict__["disable_remount"] = disable_remount
|
|
1197
|
+
__props__.__dict__["external_entropy_access"] = external_entropy_access
|
|
1198
|
+
__props__.__dict__["force_no_cache"] = force_no_cache
|
|
1199
|
+
__props__.__dict__["identity_token_key"] = identity_token_key
|
|
1200
|
+
__props__.__dict__["listing_visibility"] = listing_visibility
|
|
1201
|
+
__props__.__dict__["local"] = local
|
|
652
1202
|
__props__.__dict__["max_lease_ttl_seconds"] = max_lease_ttl_seconds
|
|
653
1203
|
__props__.__dict__["namespace"] = namespace
|
|
1204
|
+
__props__.__dict__["options"] = options
|
|
1205
|
+
__props__.__dict__["passthrough_request_headers"] = passthrough_request_headers
|
|
654
1206
|
__props__.__dict__["password"] = password
|
|
655
1207
|
__props__.__dict__["password_policy"] = password_policy
|
|
656
1208
|
__props__.__dict__["path"] = path
|
|
1209
|
+
__props__.__dict__["plugin_version"] = plugin_version
|
|
1210
|
+
__props__.__dict__["seal_wrap"] = seal_wrap
|
|
657
1211
|
__props__.__dict__["username"] = username
|
|
658
1212
|
__props__.__dict__["username_template"] = username_template
|
|
659
1213
|
__props__.__dict__["verify_connection"] = verify_connection
|
|
660
1214
|
return SecretBackend(resource_name, opts=opts, __props__=__props__)
|
|
661
1215
|
|
|
1216
|
+
@_builtins.property
|
|
1217
|
+
@pulumi.getter
|
|
1218
|
+
def accessor(self) -> pulumi.Output[_builtins.str]:
|
|
1219
|
+
"""
|
|
1220
|
+
Accessor of the mount
|
|
1221
|
+
"""
|
|
1222
|
+
return pulumi.get(self, "accessor")
|
|
1223
|
+
|
|
1224
|
+
@_builtins.property
|
|
1225
|
+
@pulumi.getter(name="allowedManagedKeys")
|
|
1226
|
+
def allowed_managed_keys(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
1227
|
+
"""
|
|
1228
|
+
List of managed key registry entry names that the mount in question is allowed to access
|
|
1229
|
+
"""
|
|
1230
|
+
return pulumi.get(self, "allowed_managed_keys")
|
|
1231
|
+
|
|
1232
|
+
@_builtins.property
|
|
1233
|
+
@pulumi.getter(name="allowedResponseHeaders")
|
|
1234
|
+
def allowed_response_headers(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
1235
|
+
"""
|
|
1236
|
+
List of headers to allow and pass from the request to the plugin
|
|
1237
|
+
"""
|
|
1238
|
+
return pulumi.get(self, "allowed_response_headers")
|
|
1239
|
+
|
|
1240
|
+
@_builtins.property
|
|
1241
|
+
@pulumi.getter(name="auditNonHmacRequestKeys")
|
|
1242
|
+
def audit_non_hmac_request_keys(self) -> pulumi.Output[Sequence[_builtins.str]]:
|
|
1243
|
+
"""
|
|
1244
|
+
Specifies the list of keys that will not be HMAC'd by audit devices in the request data object.
|
|
1245
|
+
"""
|
|
1246
|
+
return pulumi.get(self, "audit_non_hmac_request_keys")
|
|
1247
|
+
|
|
1248
|
+
@_builtins.property
|
|
1249
|
+
@pulumi.getter(name="auditNonHmacResponseKeys")
|
|
1250
|
+
def audit_non_hmac_response_keys(self) -> pulumi.Output[Sequence[_builtins.str]]:
|
|
1251
|
+
"""
|
|
1252
|
+
Specifies the list of keys that will not be HMAC'd by audit devices in the response data object.
|
|
1253
|
+
"""
|
|
1254
|
+
return pulumi.get(self, "audit_non_hmac_response_keys")
|
|
1255
|
+
|
|
662
1256
|
@_builtins.property
|
|
663
1257
|
@pulumi.getter(name="connectionUri")
|
|
664
1258
|
def connection_uri(self) -> pulumi.Output[_builtins.str]:
|
|
@@ -671,16 +1265,23 @@ class SecretBackend(pulumi.CustomResource):
|
|
|
671
1265
|
@pulumi.getter(name="defaultLeaseTtlSeconds")
|
|
672
1266
|
def default_lease_ttl_seconds(self) -> pulumi.Output[_builtins.int]:
|
|
673
1267
|
"""
|
|
674
|
-
|
|
675
|
-
issued by this backend.
|
|
1268
|
+
Default lease duration for secrets in seconds
|
|
676
1269
|
"""
|
|
677
1270
|
return pulumi.get(self, "default_lease_ttl_seconds")
|
|
678
1271
|
|
|
1272
|
+
@_builtins.property
|
|
1273
|
+
@pulumi.getter(name="delegatedAuthAccessors")
|
|
1274
|
+
def delegated_auth_accessors(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
1275
|
+
"""
|
|
1276
|
+
List of headers to allow and pass from the request to the plugin
|
|
1277
|
+
"""
|
|
1278
|
+
return pulumi.get(self, "delegated_auth_accessors")
|
|
1279
|
+
|
|
679
1280
|
@_builtins.property
|
|
680
1281
|
@pulumi.getter
|
|
681
1282
|
def description(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
682
1283
|
"""
|
|
683
|
-
|
|
1284
|
+
Human-friendly description of the mount for the backend.
|
|
684
1285
|
"""
|
|
685
1286
|
return pulumi.get(self, "description")
|
|
686
1287
|
|
|
@@ -693,12 +1294,51 @@ class SecretBackend(pulumi.CustomResource):
|
|
|
693
1294
|
"""
|
|
694
1295
|
return pulumi.get(self, "disable_remount")
|
|
695
1296
|
|
|
1297
|
+
@_builtins.property
|
|
1298
|
+
@pulumi.getter(name="externalEntropyAccess")
|
|
1299
|
+
def external_entropy_access(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1300
|
+
"""
|
|
1301
|
+
Enable the secrets engine to access Vault's external entropy source
|
|
1302
|
+
"""
|
|
1303
|
+
return pulumi.get(self, "external_entropy_access")
|
|
1304
|
+
|
|
1305
|
+
@_builtins.property
|
|
1306
|
+
@pulumi.getter(name="forceNoCache")
|
|
1307
|
+
def force_no_cache(self) -> pulumi.Output[_builtins.bool]:
|
|
1308
|
+
"""
|
|
1309
|
+
If set to true, disables caching.
|
|
1310
|
+
"""
|
|
1311
|
+
return pulumi.get(self, "force_no_cache")
|
|
1312
|
+
|
|
1313
|
+
@_builtins.property
|
|
1314
|
+
@pulumi.getter(name="identityTokenKey")
|
|
1315
|
+
def identity_token_key(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1316
|
+
"""
|
|
1317
|
+
The key to use for signing plugin workload identity tokens
|
|
1318
|
+
"""
|
|
1319
|
+
return pulumi.get(self, "identity_token_key")
|
|
1320
|
+
|
|
1321
|
+
@_builtins.property
|
|
1322
|
+
@pulumi.getter(name="listingVisibility")
|
|
1323
|
+
def listing_visibility(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1324
|
+
"""
|
|
1325
|
+
Specifies whether to show this mount in the UI-specific listing endpoint
|
|
1326
|
+
"""
|
|
1327
|
+
return pulumi.get(self, "listing_visibility")
|
|
1328
|
+
|
|
1329
|
+
@_builtins.property
|
|
1330
|
+
@pulumi.getter
|
|
1331
|
+
def local(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1332
|
+
"""
|
|
1333
|
+
Local mount flag that can be explicitly set to true to enforce local mount in HA environment
|
|
1334
|
+
"""
|
|
1335
|
+
return pulumi.get(self, "local")
|
|
1336
|
+
|
|
696
1337
|
@_builtins.property
|
|
697
1338
|
@pulumi.getter(name="maxLeaseTtlSeconds")
|
|
698
1339
|
def max_lease_ttl_seconds(self) -> pulumi.Output[_builtins.int]:
|
|
699
1340
|
"""
|
|
700
|
-
|
|
701
|
-
for credentials issued by this backend.
|
|
1341
|
+
Maximum possible lease duration for secrets in seconds
|
|
702
1342
|
"""
|
|
703
1343
|
return pulumi.get(self, "max_lease_ttl_seconds")
|
|
704
1344
|
|
|
@@ -713,6 +1353,22 @@ class SecretBackend(pulumi.CustomResource):
|
|
|
713
1353
|
"""
|
|
714
1354
|
return pulumi.get(self, "namespace")
|
|
715
1355
|
|
|
1356
|
+
@_builtins.property
|
|
1357
|
+
@pulumi.getter
|
|
1358
|
+
def options(self) -> pulumi.Output[Optional[Mapping[str, _builtins.str]]]:
|
|
1359
|
+
"""
|
|
1360
|
+
Specifies mount type specific options that are passed to the backend
|
|
1361
|
+
"""
|
|
1362
|
+
return pulumi.get(self, "options")
|
|
1363
|
+
|
|
1364
|
+
@_builtins.property
|
|
1365
|
+
@pulumi.getter(name="passthroughRequestHeaders")
|
|
1366
|
+
def passthrough_request_headers(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
1367
|
+
"""
|
|
1368
|
+
List of headers to allow and pass from the request to the plugin
|
|
1369
|
+
"""
|
|
1370
|
+
return pulumi.get(self, "passthrough_request_headers")
|
|
1371
|
+
|
|
716
1372
|
@_builtins.property
|
|
717
1373
|
@pulumi.getter
|
|
718
1374
|
def password(self) -> pulumi.Output[_builtins.str]:
|
|
@@ -738,6 +1394,22 @@ class SecretBackend(pulumi.CustomResource):
|
|
|
738
1394
|
"""
|
|
739
1395
|
return pulumi.get(self, "path")
|
|
740
1396
|
|
|
1397
|
+
@_builtins.property
|
|
1398
|
+
@pulumi.getter(name="pluginVersion")
|
|
1399
|
+
def plugin_version(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1400
|
+
"""
|
|
1401
|
+
Specifies the semantic version of the plugin to use, e.g. 'v1.0.0'
|
|
1402
|
+
"""
|
|
1403
|
+
return pulumi.get(self, "plugin_version")
|
|
1404
|
+
|
|
1405
|
+
@_builtins.property
|
|
1406
|
+
@pulumi.getter(name="sealWrap")
|
|
1407
|
+
def seal_wrap(self) -> pulumi.Output[_builtins.bool]:
|
|
1408
|
+
"""
|
|
1409
|
+
Enable seal wrapping for the mount, causing values stored by the mount to be wrapped by the seal's encryption capability
|
|
1410
|
+
"""
|
|
1411
|
+
return pulumi.get(self, "seal_wrap")
|
|
1412
|
+
|
|
741
1413
|
@_builtins.property
|
|
742
1414
|
@pulumi.getter
|
|
743
1415
|
def username(self) -> pulumi.Output[_builtins.str]:
|