pulumi-vault 7.2.0a1753339763__py3-none-any.whl → 7.2.0a1753398491__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 +1 -1
- pulumi_vault/_inputs.py +672 -673
- pulumi_vault/ad/__init__.py +1 -1
- pulumi_vault/ad/get_access_credentials.py +27 -28
- pulumi_vault/ad/secret_backend.py +579 -580
- pulumi_vault/ad/secret_library.py +120 -121
- pulumi_vault/ad/secret_role.py +104 -105
- pulumi_vault/alicloud/__init__.py +1 -1
- pulumi_vault/alicloud/auth_backend_role.py +222 -223
- pulumi_vault/approle/__init__.py +1 -1
- pulumi_vault/approle/auth_backend_login.py +138 -139
- pulumi_vault/approle/auth_backend_role.py +292 -293
- pulumi_vault/approle/auth_backend_role_secret_id.py +202 -203
- pulumi_vault/approle/get_auth_backend_role_id.py +23 -24
- pulumi_vault/audit.py +103 -104
- pulumi_vault/audit_request_header.py +52 -53
- pulumi_vault/auth_backend.py +132 -133
- pulumi_vault/aws/__init__.py +1 -1
- pulumi_vault/aws/auth_backend_cert.py +86 -87
- pulumi_vault/aws/auth_backend_client.py +307 -308
- pulumi_vault/aws/auth_backend_config_identity.py +103 -104
- pulumi_vault/aws/auth_backend_identity_whitelist.py +69 -70
- pulumi_vault/aws/auth_backend_login.py +258 -259
- pulumi_vault/aws/auth_backend_role.py +486 -487
- pulumi_vault/aws/auth_backend_role_tag.py +155 -156
- pulumi_vault/aws/auth_backend_roletag_blacklist.py +69 -70
- pulumi_vault/aws/auth_backend_sts_role.py +86 -87
- pulumi_vault/aws/get_access_credentials.py +59 -60
- pulumi_vault/aws/get_static_access_credentials.py +19 -20
- pulumi_vault/aws/secret_backend.py +409 -410
- pulumi_vault/aws/secret_backend_role.py +256 -257
- pulumi_vault/aws/secret_backend_static_role.py +137 -138
- pulumi_vault/azure/__init__.py +1 -1
- pulumi_vault/azure/_inputs.py +26 -27
- pulumi_vault/azure/auth_backend_config.py +222 -223
- pulumi_vault/azure/auth_backend_role.py +307 -308
- pulumi_vault/azure/backend.py +273 -274
- pulumi_vault/azure/backend_role.py +194 -195
- pulumi_vault/azure/get_access_credentials.py +75 -76
- pulumi_vault/azure/outputs.py +16 -17
- pulumi_vault/cert_auth_backend_role.py +443 -444
- pulumi_vault/config/__init__.py +1 -1
- pulumi_vault/config/__init__.pyi +1 -2
- pulumi_vault/config/_inputs.py +13 -14
- pulumi_vault/config/outputs.py +380 -381
- pulumi_vault/config/ui_custom_message.py +140 -141
- pulumi_vault/config/vars.py +31 -32
- pulumi_vault/consul/__init__.py +1 -1
- pulumi_vault/consul/secret_backend.py +239 -240
- pulumi_vault/consul/secret_backend_role.py +222 -223
- pulumi_vault/database/__init__.py +1 -1
- pulumi_vault/database/_inputs.py +3167 -3168
- pulumi_vault/database/outputs.py +2123 -2124
- pulumi_vault/database/secret_backend_connection.py +259 -260
- pulumi_vault/database/secret_backend_role.py +205 -206
- pulumi_vault/database/secret_backend_static_role.py +218 -219
- pulumi_vault/database/secrets_mount.py +379 -380
- pulumi_vault/egp_policy.py +86 -87
- pulumi_vault/gcp/__init__.py +1 -1
- pulumi_vault/gcp/_inputs.py +98 -99
- pulumi_vault/gcp/auth_backend.py +322 -323
- pulumi_vault/gcp/auth_backend_role.py +347 -348
- pulumi_vault/gcp/get_auth_backend_role.py +91 -92
- pulumi_vault/gcp/outputs.py +66 -67
- pulumi_vault/gcp/secret_backend.py +299 -300
- pulumi_vault/gcp/secret_impersonated_account.py +112 -113
- pulumi_vault/gcp/secret_roleset.py +115 -116
- pulumi_vault/gcp/secret_static_account.py +115 -116
- pulumi_vault/generic/__init__.py +1 -1
- pulumi_vault/generic/endpoint.py +138 -139
- pulumi_vault/generic/get_secret.py +39 -40
- pulumi_vault/generic/secret.py +95 -96
- pulumi_vault/get_auth_backend.py +29 -30
- pulumi_vault/get_auth_backends.py +19 -20
- pulumi_vault/get_namespace.py +21 -22
- pulumi_vault/get_namespaces.py +19 -20
- pulumi_vault/get_nomad_access_token.py +25 -26
- pulumi_vault/get_policy_document.py +10 -11
- pulumi_vault/get_raft_autopilot_state.py +31 -32
- pulumi_vault/github/__init__.py +1 -1
- pulumi_vault/github/_inputs.py +50 -51
- pulumi_vault/github/auth_backend.py +285 -286
- pulumi_vault/github/outputs.py +34 -35
- pulumi_vault/github/team.py +69 -70
- pulumi_vault/github/user.py +69 -70
- pulumi_vault/identity/__init__.py +1 -1
- pulumi_vault/identity/entity.py +103 -104
- pulumi_vault/identity/entity_alias.py +86 -87
- pulumi_vault/identity/entity_policies.py +78 -79
- pulumi_vault/identity/get_entity.py +62 -63
- pulumi_vault/identity/get_group.py +75 -76
- pulumi_vault/identity/get_oidc_client_creds.py +19 -20
- pulumi_vault/identity/get_oidc_openid_config.py +39 -40
- pulumi_vault/identity/get_oidc_public_keys.py +17 -18
- pulumi_vault/identity/group.py +171 -172
- pulumi_vault/identity/group_alias.py +69 -70
- pulumi_vault/identity/group_member_entity_ids.py +69 -70
- pulumi_vault/identity/group_member_group_ids.py +69 -70
- pulumi_vault/identity/group_policies.py +78 -79
- pulumi_vault/identity/mfa_duo.py +183 -184
- pulumi_vault/identity/mfa_login_enforcement.py +147 -148
- pulumi_vault/identity/mfa_okta.py +166 -167
- pulumi_vault/identity/mfa_pingid.py +160 -161
- pulumi_vault/identity/mfa_totp.py +217 -218
- pulumi_vault/identity/oidc.py +35 -36
- pulumi_vault/identity/oidc_assignment.py +69 -70
- pulumi_vault/identity/oidc_client.py +155 -156
- pulumi_vault/identity/oidc_key.py +103 -104
- pulumi_vault/identity/oidc_key_allowed_client_id.py +52 -53
- pulumi_vault/identity/oidc_provider.py +112 -113
- pulumi_vault/identity/oidc_role.py +103 -104
- pulumi_vault/identity/oidc_scope.py +69 -70
- pulumi_vault/identity/outputs.py +42 -43
- pulumi_vault/jwt/__init__.py +1 -1
- pulumi_vault/jwt/_inputs.py +50 -51
- pulumi_vault/jwt/auth_backend.py +353 -354
- pulumi_vault/jwt/auth_backend_role.py +494 -495
- pulumi_vault/jwt/outputs.py +34 -35
- pulumi_vault/kmip/__init__.py +1 -1
- pulumi_vault/kmip/secret_backend.py +222 -223
- pulumi_vault/kmip/secret_role.py +358 -359
- pulumi_vault/kmip/secret_scope.py +69 -70
- pulumi_vault/kubernetes/__init__.py +1 -1
- pulumi_vault/kubernetes/auth_backend_config.py +171 -172
- pulumi_vault/kubernetes/auth_backend_role.py +273 -274
- pulumi_vault/kubernetes/get_auth_backend_config.py +57 -58
- pulumi_vault/kubernetes/get_auth_backend_role.py +87 -88
- pulumi_vault/kubernetes/get_service_account_token.py +51 -52
- pulumi_vault/kubernetes/secret_backend.py +384 -385
- pulumi_vault/kubernetes/secret_backend_role.py +239 -240
- pulumi_vault/kv/__init__.py +1 -1
- pulumi_vault/kv/_inputs.py +25 -26
- pulumi_vault/kv/get_secret.py +25 -26
- pulumi_vault/kv/get_secret_subkeys_v2.py +39 -40
- pulumi_vault/kv/get_secret_v2.py +41 -42
- pulumi_vault/kv/get_secrets_list.py +17 -18
- pulumi_vault/kv/get_secrets_list_v2.py +25 -26
- pulumi_vault/kv/outputs.py +17 -18
- pulumi_vault/kv/secret.py +61 -62
- pulumi_vault/kv/secret_backend_v2.py +86 -87
- pulumi_vault/kv/secret_v2.py +184 -185
- pulumi_vault/ldap/__init__.py +1 -1
- pulumi_vault/ldap/auth_backend.py +716 -717
- pulumi_vault/ldap/auth_backend_group.py +69 -70
- pulumi_vault/ldap/auth_backend_user.py +86 -87
- pulumi_vault/ldap/get_dynamic_credentials.py +27 -28
- pulumi_vault/ldap/get_static_credentials.py +29 -30
- pulumi_vault/ldap/secret_backend.py +673 -674
- pulumi_vault/ldap/secret_backend_dynamic_role.py +154 -155
- pulumi_vault/ldap/secret_backend_library_set.py +120 -121
- pulumi_vault/ldap/secret_backend_static_role.py +120 -121
- pulumi_vault/managed/__init__.py +1 -1
- pulumi_vault/managed/_inputs.py +274 -275
- pulumi_vault/managed/keys.py +27 -28
- pulumi_vault/managed/outputs.py +184 -185
- pulumi_vault/mfa_duo.py +137 -138
- pulumi_vault/mfa_okta.py +137 -138
- pulumi_vault/mfa_pingid.py +149 -150
- pulumi_vault/mfa_totp.py +154 -155
- pulumi_vault/mongodbatlas/__init__.py +1 -1
- pulumi_vault/mongodbatlas/secret_backend.py +78 -79
- pulumi_vault/mongodbatlas/secret_role.py +188 -189
- pulumi_vault/mount.py +333 -334
- pulumi_vault/namespace.py +78 -79
- pulumi_vault/nomad_secret_backend.py +256 -257
- pulumi_vault/nomad_secret_role.py +103 -104
- pulumi_vault/okta/__init__.py +1 -1
- pulumi_vault/okta/_inputs.py +31 -32
- pulumi_vault/okta/auth_backend.py +305 -306
- pulumi_vault/okta/auth_backend_group.py +69 -70
- pulumi_vault/okta/auth_backend_user.py +86 -87
- pulumi_vault/okta/outputs.py +21 -22
- pulumi_vault/outputs.py +81 -82
- pulumi_vault/pkisecret/__init__.py +1 -1
- pulumi_vault/pkisecret/_inputs.py +55 -56
- pulumi_vault/pkisecret/backend_acme_eab.py +116 -117
- pulumi_vault/pkisecret/backend_config_acme.py +175 -176
- pulumi_vault/pkisecret/backend_config_auto_tidy.py +394 -395
- pulumi_vault/pkisecret/backend_config_cluster.py +71 -72
- pulumi_vault/pkisecret/backend_config_cmpv2.py +132 -133
- pulumi_vault/pkisecret/backend_config_est.py +149 -150
- pulumi_vault/pkisecret/backend_config_scep.py +137 -138
- pulumi_vault/pkisecret/get_backend_cert_metadata.py +37 -38
- pulumi_vault/pkisecret/get_backend_config_cmpv2.py +32 -33
- pulumi_vault/pkisecret/get_backend_config_est.py +30 -31
- pulumi_vault/pkisecret/get_backend_config_scep.py +29 -30
- pulumi_vault/pkisecret/get_backend_issuer.py +63 -64
- pulumi_vault/pkisecret/get_backend_issuers.py +23 -24
- pulumi_vault/pkisecret/get_backend_key.py +29 -30
- pulumi_vault/pkisecret/get_backend_keys.py +23 -24
- pulumi_vault/pkisecret/outputs.py +61 -62
- pulumi_vault/pkisecret/secret_backend_cert.py +415 -416
- pulumi_vault/pkisecret/secret_backend_config_ca.py +54 -55
- pulumi_vault/pkisecret/secret_backend_config_issuers.py +75 -76
- pulumi_vault/pkisecret/secret_backend_config_urls.py +105 -106
- pulumi_vault/pkisecret/secret_backend_crl_config.py +241 -242
- pulumi_vault/pkisecret/secret_backend_intermediate_cert_request.py +515 -516
- pulumi_vault/pkisecret/secret_backend_intermediate_set_signed.py +78 -79
- pulumi_vault/pkisecret/secret_backend_issuer.py +286 -287
- pulumi_vault/pkisecret/secret_backend_key.py +146 -147
- pulumi_vault/pkisecret/secret_backend_role.py +873 -874
- pulumi_vault/pkisecret/secret_backend_root_cert.py +677 -678
- pulumi_vault/pkisecret/secret_backend_root_sign_intermediate.py +660 -661
- pulumi_vault/pkisecret/secret_backend_sign.py +346 -347
- pulumi_vault/plugin.py +154 -155
- pulumi_vault/plugin_pinned_version.py +52 -53
- pulumi_vault/policy.py +52 -53
- pulumi_vault/provider.py +160 -161
- pulumi_vault/pulumi-plugin.json +1 -1
- pulumi_vault/quota_lease_count.py +103 -104
- pulumi_vault/quota_rate_limit.py +171 -172
- pulumi_vault/rabbitmq/__init__.py +1 -1
- pulumi_vault/rabbitmq/_inputs.py +50 -51
- pulumi_vault/rabbitmq/outputs.py +34 -35
- pulumi_vault/rabbitmq/secret_backend.py +207 -208
- pulumi_vault/rabbitmq/secret_backend_role.py +79 -80
- pulumi_vault/raft_autopilot.py +137 -138
- pulumi_vault/raft_snapshot_agent_config.py +477 -478
- pulumi_vault/rgp_policy.py +69 -70
- pulumi_vault/saml/__init__.py +1 -1
- pulumi_vault/saml/auth_backend.py +188 -189
- pulumi_vault/saml/auth_backend_role.py +290 -291
- pulumi_vault/scep_auth_backend_role.py +252 -253
- pulumi_vault/secrets/__init__.py +1 -1
- pulumi_vault/secrets/_inputs.py +19 -20
- pulumi_vault/secrets/outputs.py +13 -14
- pulumi_vault/secrets/sync_association.py +88 -89
- pulumi_vault/secrets/sync_aws_destination.py +180 -181
- pulumi_vault/secrets/sync_azure_destination.py +180 -181
- pulumi_vault/secrets/sync_config.py +52 -53
- pulumi_vault/secrets/sync_gcp_destination.py +129 -130
- pulumi_vault/secrets/sync_gh_destination.py +163 -164
- pulumi_vault/secrets/sync_github_apps.py +78 -79
- pulumi_vault/secrets/sync_vercel_destination.py +146 -147
- pulumi_vault/ssh/__init__.py +1 -1
- pulumi_vault/ssh/_inputs.py +13 -14
- pulumi_vault/ssh/get_secret_backend_sign.py +65 -66
- pulumi_vault/ssh/outputs.py +9 -10
- pulumi_vault/ssh/secret_backend_ca.py +120 -121
- pulumi_vault/ssh/secret_backend_role.py +446 -447
- pulumi_vault/terraformcloud/__init__.py +1 -1
- pulumi_vault/terraformcloud/secret_backend.py +138 -139
- pulumi_vault/terraformcloud/secret_creds.py +93 -94
- pulumi_vault/terraformcloud/secret_role.py +117 -118
- pulumi_vault/token.py +301 -302
- pulumi_vault/tokenauth/__init__.py +1 -1
- pulumi_vault/tokenauth/auth_backend_role.py +324 -325
- pulumi_vault/transform/__init__.py +1 -1
- pulumi_vault/transform/alphabet.py +69 -70
- pulumi_vault/transform/get_decode.py +57 -58
- pulumi_vault/transform/get_encode.py +57 -58
- pulumi_vault/transform/role.py +69 -70
- pulumi_vault/transform/template.py +137 -138
- pulumi_vault/transform/transformation.py +171 -172
- pulumi_vault/transit/__init__.py +1 -1
- pulumi_vault/transit/get_cmac.py +47 -48
- pulumi_vault/transit/get_decrypt.py +25 -26
- pulumi_vault/transit/get_encrypt.py +29 -30
- pulumi_vault/transit/get_sign.py +71 -72
- pulumi_vault/transit/get_verify.py +83 -84
- pulumi_vault/transit/secret_backend_key.py +336 -337
- pulumi_vault/transit/secret_cache_config.py +52 -53
- {pulumi_vault-7.2.0a1753339763.dist-info → pulumi_vault-7.2.0a1753398491.dist-info}/METADATA +1 -1
- pulumi_vault-7.2.0a1753398491.dist-info/RECORD +268 -0
- pulumi_vault-7.2.0a1753339763.dist-info/RECORD +0 -268
- {pulumi_vault-7.2.0a1753339763.dist-info → pulumi_vault-7.2.0a1753398491.dist-info}/WHEEL +0 -0
- {pulumi_vault-7.2.0a1753339763.dist-info → pulumi_vault-7.2.0a1753398491.dist-info}/top_level.txt +0 -0
|
@@ -2,8 +2,7 @@
|
|
|
2
2
|
# *** WARNING: this file was generated by pulumi-language-python. ***
|
|
3
3
|
# *** Do not edit by hand unless you're certain you know what you are doing! ***
|
|
4
4
|
|
|
5
|
-
import builtins
|
|
6
|
-
import copy
|
|
5
|
+
import builtins as _builtins
|
|
7
6
|
import warnings
|
|
8
7
|
import sys
|
|
9
8
|
import pulumi
|
|
@@ -22,70 +21,70 @@ __all__ = ['SecretBackendRoleArgs', 'SecretBackendRole']
|
|
|
22
21
|
@pulumi.input_type
|
|
23
22
|
class SecretBackendRoleArgs:
|
|
24
23
|
def __init__(__self__, *,
|
|
25
|
-
backend: pulumi.Input[
|
|
26
|
-
key_type: pulumi.Input[
|
|
27
|
-
algorithm_signer: Optional[pulumi.Input[
|
|
28
|
-
allow_bare_domains: Optional[pulumi.Input[
|
|
29
|
-
allow_empty_principals: Optional[pulumi.Input[
|
|
30
|
-
allow_host_certificates: Optional[pulumi.Input[
|
|
31
|
-
allow_subdomains: Optional[pulumi.Input[
|
|
32
|
-
allow_user_certificates: Optional[pulumi.Input[
|
|
33
|
-
allow_user_key_ids: Optional[pulumi.Input[
|
|
34
|
-
allowed_critical_options: Optional[pulumi.Input[
|
|
35
|
-
allowed_domains: Optional[pulumi.Input[
|
|
36
|
-
allowed_domains_template: Optional[pulumi.Input[
|
|
37
|
-
allowed_extensions: Optional[pulumi.Input[
|
|
24
|
+
backend: pulumi.Input[_builtins.str],
|
|
25
|
+
key_type: pulumi.Input[_builtins.str],
|
|
26
|
+
algorithm_signer: Optional[pulumi.Input[_builtins.str]] = None,
|
|
27
|
+
allow_bare_domains: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
28
|
+
allow_empty_principals: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
29
|
+
allow_host_certificates: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
30
|
+
allow_subdomains: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
31
|
+
allow_user_certificates: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
32
|
+
allow_user_key_ids: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
33
|
+
allowed_critical_options: Optional[pulumi.Input[_builtins.str]] = None,
|
|
34
|
+
allowed_domains: Optional[pulumi.Input[_builtins.str]] = None,
|
|
35
|
+
allowed_domains_template: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
36
|
+
allowed_extensions: Optional[pulumi.Input[_builtins.str]] = None,
|
|
38
37
|
allowed_user_key_configs: Optional[pulumi.Input[Sequence[pulumi.Input['SecretBackendRoleAllowedUserKeyConfigArgs']]]] = None,
|
|
39
|
-
allowed_users: Optional[pulumi.Input[
|
|
40
|
-
allowed_users_template: Optional[pulumi.Input[
|
|
41
|
-
cidr_list: Optional[pulumi.Input[
|
|
42
|
-
default_critical_options: Optional[pulumi.Input[Mapping[str, pulumi.Input[
|
|
43
|
-
default_extensions: Optional[pulumi.Input[Mapping[str, pulumi.Input[
|
|
44
|
-
default_user: Optional[pulumi.Input[
|
|
45
|
-
default_user_template: Optional[pulumi.Input[
|
|
46
|
-
key_id_format: Optional[pulumi.Input[
|
|
47
|
-
max_ttl: Optional[pulumi.Input[
|
|
48
|
-
name: Optional[pulumi.Input[
|
|
49
|
-
namespace: Optional[pulumi.Input[
|
|
50
|
-
not_before_duration: Optional[pulumi.Input[
|
|
51
|
-
ttl: Optional[pulumi.Input[
|
|
38
|
+
allowed_users: Optional[pulumi.Input[_builtins.str]] = None,
|
|
39
|
+
allowed_users_template: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
40
|
+
cidr_list: Optional[pulumi.Input[_builtins.str]] = None,
|
|
41
|
+
default_critical_options: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
|
|
42
|
+
default_extensions: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
|
|
43
|
+
default_user: Optional[pulumi.Input[_builtins.str]] = None,
|
|
44
|
+
default_user_template: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
45
|
+
key_id_format: Optional[pulumi.Input[_builtins.str]] = None,
|
|
46
|
+
max_ttl: Optional[pulumi.Input[_builtins.str]] = None,
|
|
47
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
48
|
+
namespace: Optional[pulumi.Input[_builtins.str]] = None,
|
|
49
|
+
not_before_duration: Optional[pulumi.Input[_builtins.str]] = None,
|
|
50
|
+
ttl: Optional[pulumi.Input[_builtins.str]] = None):
|
|
52
51
|
"""
|
|
53
52
|
The set of arguments for constructing a SecretBackendRole resource.
|
|
54
|
-
:param pulumi.Input[
|
|
55
|
-
:param pulumi.Input[
|
|
56
|
-
:param pulumi.Input[
|
|
57
|
-
:param pulumi.Input[
|
|
58
|
-
:param pulumi.Input[
|
|
53
|
+
:param pulumi.Input[_builtins.str] backend: The path where the SSH secret backend is mounted.
|
|
54
|
+
:param pulumi.Input[_builtins.str] key_type: Specifies the type of credentials generated by this role. This can be either `otp`, `dynamic` or `ca`.
|
|
55
|
+
:param pulumi.Input[_builtins.str] algorithm_signer: When supplied, this value specifies a signing algorithm for the key. Possible values: ssh-rsa, rsa-sha2-256, rsa-sha2-512.
|
|
56
|
+
:param pulumi.Input[_builtins.bool] allow_bare_domains: Specifies if host certificates that are requested are allowed to use the base domains listed in `allowed_domains`.
|
|
57
|
+
:param pulumi.Input[_builtins.bool] allow_empty_principals: Allow signing certificates with no
|
|
59
58
|
valid principals (e.g. any valid principal). For backwards compatibility
|
|
60
59
|
only. The default of false is highly recommended.
|
|
61
|
-
:param pulumi.Input[
|
|
62
|
-
:param pulumi.Input[
|
|
63
|
-
:param pulumi.Input[
|
|
64
|
-
:param pulumi.Input[
|
|
65
|
-
:param pulumi.Input[
|
|
66
|
-
:param pulumi.Input[
|
|
67
|
-
:param pulumi.Input[
|
|
60
|
+
:param pulumi.Input[_builtins.bool] allow_host_certificates: Specifies if certificates are allowed to be signed for use as a 'host'.
|
|
61
|
+
:param pulumi.Input[_builtins.bool] allow_subdomains: Specifies if host certificates that are requested are allowed to be subdomains of those listed in `allowed_domains`.
|
|
62
|
+
:param pulumi.Input[_builtins.bool] allow_user_certificates: Specifies if certificates are allowed to be signed for use as a 'user'.
|
|
63
|
+
:param pulumi.Input[_builtins.bool] allow_user_key_ids: Specifies if users can override the key ID for a signed certificate with the `key_id` field.
|
|
64
|
+
:param pulumi.Input[_builtins.str] allowed_critical_options: Specifies a comma-separated list of critical options that certificates can have when signed.
|
|
65
|
+
:param pulumi.Input[_builtins.str] allowed_domains: The list of domains for which a client can request a host certificate.
|
|
66
|
+
:param pulumi.Input[_builtins.bool] allowed_domains_template: Specifies if `allowed_domains` can be declared using
|
|
68
67
|
identity template policies. Non-templated domains are also permitted.
|
|
69
|
-
:param pulumi.Input[
|
|
68
|
+
:param pulumi.Input[_builtins.str] allowed_extensions: Specifies a comma-separated list of extensions that certificates can have when signed.
|
|
70
69
|
:param pulumi.Input[Sequence[pulumi.Input['SecretBackendRoleAllowedUserKeyConfigArgs']]] allowed_user_key_configs: Set of configuration blocks to define allowed
|
|
71
70
|
user key configuration, like key type and their lengths. Can be specified multiple times.
|
|
72
71
|
*See Configuration-Options for more info*
|
|
73
|
-
:param pulumi.Input[
|
|
74
|
-
:param pulumi.Input[
|
|
75
|
-
:param pulumi.Input[
|
|
76
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[
|
|
77
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[
|
|
78
|
-
:param pulumi.Input[
|
|
79
|
-
:param pulumi.Input[
|
|
80
|
-
:param pulumi.Input[
|
|
81
|
-
:param pulumi.Input[
|
|
82
|
-
:param pulumi.Input[
|
|
83
|
-
:param pulumi.Input[
|
|
72
|
+
:param pulumi.Input[_builtins.str] allowed_users: Specifies a comma-separated list of usernames that are to be allowed, only if certain usernames are to be allowed.
|
|
73
|
+
:param pulumi.Input[_builtins.bool] allowed_users_template: Specifies if `allowed_users` can be declared using identity template policies. Non-templated users are also permitted.
|
|
74
|
+
:param pulumi.Input[_builtins.str] cidr_list: The comma-separated string of CIDR blocks for which this role is applicable.
|
|
75
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] default_critical_options: Specifies a map of critical options that certificates have when signed.
|
|
76
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] default_extensions: Specifies a map of extensions that certificates have when signed.
|
|
77
|
+
:param pulumi.Input[_builtins.str] default_user: Specifies the default username for which a credential will be generated.
|
|
78
|
+
:param pulumi.Input[_builtins.bool] default_user_template: If set, `default_users` can be specified using identity template values. A non-templated user is also permitted.
|
|
79
|
+
:param pulumi.Input[_builtins.str] key_id_format: Specifies a custom format for the key id of a signed certificate.
|
|
80
|
+
:param pulumi.Input[_builtins.str] max_ttl: Specifies the maximum Time To Live value.
|
|
81
|
+
:param pulumi.Input[_builtins.str] name: Specifies the name of the role to create.
|
|
82
|
+
:param pulumi.Input[_builtins.str] namespace: The namespace to provision the resource in.
|
|
84
83
|
The value should not contain leading or trailing forward slashes.
|
|
85
84
|
The `namespace` is always relative to the provider's configured [namespace](https://www.terraform.io/docs/providers/vault/index.html#namespace).
|
|
86
85
|
*Available only for Vault Enterprise*.
|
|
87
|
-
:param pulumi.Input[
|
|
88
|
-
:param pulumi.Input[
|
|
86
|
+
:param pulumi.Input[_builtins.str] not_before_duration: Specifies the duration by which to backdate the ValidAfter property. Uses duration format strings.
|
|
87
|
+
:param pulumi.Input[_builtins.str] ttl: Specifies the Time To Live value.
|
|
89
88
|
"""
|
|
90
89
|
pulumi.set(__self__, "backend", backend)
|
|
91
90
|
pulumi.set(__self__, "key_type", key_type)
|
|
@@ -140,57 +139,57 @@ class SecretBackendRoleArgs:
|
|
|
140
139
|
if ttl is not None:
|
|
141
140
|
pulumi.set(__self__, "ttl", ttl)
|
|
142
141
|
|
|
143
|
-
@property
|
|
142
|
+
@_builtins.property
|
|
144
143
|
@pulumi.getter
|
|
145
|
-
def backend(self) -> pulumi.Input[
|
|
144
|
+
def backend(self) -> pulumi.Input[_builtins.str]:
|
|
146
145
|
"""
|
|
147
146
|
The path where the SSH secret backend is mounted.
|
|
148
147
|
"""
|
|
149
148
|
return pulumi.get(self, "backend")
|
|
150
149
|
|
|
151
150
|
@backend.setter
|
|
152
|
-
def backend(self, value: pulumi.Input[
|
|
151
|
+
def backend(self, value: pulumi.Input[_builtins.str]):
|
|
153
152
|
pulumi.set(self, "backend", value)
|
|
154
153
|
|
|
155
|
-
@property
|
|
154
|
+
@_builtins.property
|
|
156
155
|
@pulumi.getter(name="keyType")
|
|
157
|
-
def key_type(self) -> pulumi.Input[
|
|
156
|
+
def key_type(self) -> pulumi.Input[_builtins.str]:
|
|
158
157
|
"""
|
|
159
158
|
Specifies the type of credentials generated by this role. This can be either `otp`, `dynamic` or `ca`.
|
|
160
159
|
"""
|
|
161
160
|
return pulumi.get(self, "key_type")
|
|
162
161
|
|
|
163
162
|
@key_type.setter
|
|
164
|
-
def key_type(self, value: pulumi.Input[
|
|
163
|
+
def key_type(self, value: pulumi.Input[_builtins.str]):
|
|
165
164
|
pulumi.set(self, "key_type", value)
|
|
166
165
|
|
|
167
|
-
@property
|
|
166
|
+
@_builtins.property
|
|
168
167
|
@pulumi.getter(name="algorithmSigner")
|
|
169
|
-
def algorithm_signer(self) -> Optional[pulumi.Input[
|
|
168
|
+
def algorithm_signer(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
170
169
|
"""
|
|
171
170
|
When supplied, this value specifies a signing algorithm for the key. Possible values: ssh-rsa, rsa-sha2-256, rsa-sha2-512.
|
|
172
171
|
"""
|
|
173
172
|
return pulumi.get(self, "algorithm_signer")
|
|
174
173
|
|
|
175
174
|
@algorithm_signer.setter
|
|
176
|
-
def algorithm_signer(self, value: Optional[pulumi.Input[
|
|
175
|
+
def algorithm_signer(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
177
176
|
pulumi.set(self, "algorithm_signer", value)
|
|
178
177
|
|
|
179
|
-
@property
|
|
178
|
+
@_builtins.property
|
|
180
179
|
@pulumi.getter(name="allowBareDomains")
|
|
181
|
-
def allow_bare_domains(self) -> Optional[pulumi.Input[
|
|
180
|
+
def allow_bare_domains(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
182
181
|
"""
|
|
183
182
|
Specifies if host certificates that are requested are allowed to use the base domains listed in `allowed_domains`.
|
|
184
183
|
"""
|
|
185
184
|
return pulumi.get(self, "allow_bare_domains")
|
|
186
185
|
|
|
187
186
|
@allow_bare_domains.setter
|
|
188
|
-
def allow_bare_domains(self, value: Optional[pulumi.Input[
|
|
187
|
+
def allow_bare_domains(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
189
188
|
pulumi.set(self, "allow_bare_domains", value)
|
|
190
189
|
|
|
191
|
-
@property
|
|
190
|
+
@_builtins.property
|
|
192
191
|
@pulumi.getter(name="allowEmptyPrincipals")
|
|
193
|
-
def allow_empty_principals(self) -> Optional[pulumi.Input[
|
|
192
|
+
def allow_empty_principals(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
194
193
|
"""
|
|
195
194
|
Allow signing certificates with no
|
|
196
195
|
valid principals (e.g. any valid principal). For backwards compatibility
|
|
@@ -199,84 +198,84 @@ class SecretBackendRoleArgs:
|
|
|
199
198
|
return pulumi.get(self, "allow_empty_principals")
|
|
200
199
|
|
|
201
200
|
@allow_empty_principals.setter
|
|
202
|
-
def allow_empty_principals(self, value: Optional[pulumi.Input[
|
|
201
|
+
def allow_empty_principals(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
203
202
|
pulumi.set(self, "allow_empty_principals", value)
|
|
204
203
|
|
|
205
|
-
@property
|
|
204
|
+
@_builtins.property
|
|
206
205
|
@pulumi.getter(name="allowHostCertificates")
|
|
207
|
-
def allow_host_certificates(self) -> Optional[pulumi.Input[
|
|
206
|
+
def allow_host_certificates(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
208
207
|
"""
|
|
209
208
|
Specifies if certificates are allowed to be signed for use as a 'host'.
|
|
210
209
|
"""
|
|
211
210
|
return pulumi.get(self, "allow_host_certificates")
|
|
212
211
|
|
|
213
212
|
@allow_host_certificates.setter
|
|
214
|
-
def allow_host_certificates(self, value: Optional[pulumi.Input[
|
|
213
|
+
def allow_host_certificates(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
215
214
|
pulumi.set(self, "allow_host_certificates", value)
|
|
216
215
|
|
|
217
|
-
@property
|
|
216
|
+
@_builtins.property
|
|
218
217
|
@pulumi.getter(name="allowSubdomains")
|
|
219
|
-
def allow_subdomains(self) -> Optional[pulumi.Input[
|
|
218
|
+
def allow_subdomains(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
220
219
|
"""
|
|
221
220
|
Specifies if host certificates that are requested are allowed to be subdomains of those listed in `allowed_domains`.
|
|
222
221
|
"""
|
|
223
222
|
return pulumi.get(self, "allow_subdomains")
|
|
224
223
|
|
|
225
224
|
@allow_subdomains.setter
|
|
226
|
-
def allow_subdomains(self, value: Optional[pulumi.Input[
|
|
225
|
+
def allow_subdomains(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
227
226
|
pulumi.set(self, "allow_subdomains", value)
|
|
228
227
|
|
|
229
|
-
@property
|
|
228
|
+
@_builtins.property
|
|
230
229
|
@pulumi.getter(name="allowUserCertificates")
|
|
231
|
-
def allow_user_certificates(self) -> Optional[pulumi.Input[
|
|
230
|
+
def allow_user_certificates(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
232
231
|
"""
|
|
233
232
|
Specifies if certificates are allowed to be signed for use as a 'user'.
|
|
234
233
|
"""
|
|
235
234
|
return pulumi.get(self, "allow_user_certificates")
|
|
236
235
|
|
|
237
236
|
@allow_user_certificates.setter
|
|
238
|
-
def allow_user_certificates(self, value: Optional[pulumi.Input[
|
|
237
|
+
def allow_user_certificates(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
239
238
|
pulumi.set(self, "allow_user_certificates", value)
|
|
240
239
|
|
|
241
|
-
@property
|
|
240
|
+
@_builtins.property
|
|
242
241
|
@pulumi.getter(name="allowUserKeyIds")
|
|
243
|
-
def allow_user_key_ids(self) -> Optional[pulumi.Input[
|
|
242
|
+
def allow_user_key_ids(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
244
243
|
"""
|
|
245
244
|
Specifies if users can override the key ID for a signed certificate with the `key_id` field.
|
|
246
245
|
"""
|
|
247
246
|
return pulumi.get(self, "allow_user_key_ids")
|
|
248
247
|
|
|
249
248
|
@allow_user_key_ids.setter
|
|
250
|
-
def allow_user_key_ids(self, value: Optional[pulumi.Input[
|
|
249
|
+
def allow_user_key_ids(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
251
250
|
pulumi.set(self, "allow_user_key_ids", value)
|
|
252
251
|
|
|
253
|
-
@property
|
|
252
|
+
@_builtins.property
|
|
254
253
|
@pulumi.getter(name="allowedCriticalOptions")
|
|
255
|
-
def allowed_critical_options(self) -> Optional[pulumi.Input[
|
|
254
|
+
def allowed_critical_options(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
256
255
|
"""
|
|
257
256
|
Specifies a comma-separated list of critical options that certificates can have when signed.
|
|
258
257
|
"""
|
|
259
258
|
return pulumi.get(self, "allowed_critical_options")
|
|
260
259
|
|
|
261
260
|
@allowed_critical_options.setter
|
|
262
|
-
def allowed_critical_options(self, value: Optional[pulumi.Input[
|
|
261
|
+
def allowed_critical_options(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
263
262
|
pulumi.set(self, "allowed_critical_options", value)
|
|
264
263
|
|
|
265
|
-
@property
|
|
264
|
+
@_builtins.property
|
|
266
265
|
@pulumi.getter(name="allowedDomains")
|
|
267
|
-
def allowed_domains(self) -> Optional[pulumi.Input[
|
|
266
|
+
def allowed_domains(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
268
267
|
"""
|
|
269
268
|
The list of domains for which a client can request a host certificate.
|
|
270
269
|
"""
|
|
271
270
|
return pulumi.get(self, "allowed_domains")
|
|
272
271
|
|
|
273
272
|
@allowed_domains.setter
|
|
274
|
-
def allowed_domains(self, value: Optional[pulumi.Input[
|
|
273
|
+
def allowed_domains(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
275
274
|
pulumi.set(self, "allowed_domains", value)
|
|
276
275
|
|
|
277
|
-
@property
|
|
276
|
+
@_builtins.property
|
|
278
277
|
@pulumi.getter(name="allowedDomainsTemplate")
|
|
279
|
-
def allowed_domains_template(self) -> Optional[pulumi.Input[
|
|
278
|
+
def allowed_domains_template(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
280
279
|
"""
|
|
281
280
|
Specifies if `allowed_domains` can be declared using
|
|
282
281
|
identity template policies. Non-templated domains are also permitted.
|
|
@@ -284,22 +283,22 @@ class SecretBackendRoleArgs:
|
|
|
284
283
|
return pulumi.get(self, "allowed_domains_template")
|
|
285
284
|
|
|
286
285
|
@allowed_domains_template.setter
|
|
287
|
-
def allowed_domains_template(self, value: Optional[pulumi.Input[
|
|
286
|
+
def allowed_domains_template(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
288
287
|
pulumi.set(self, "allowed_domains_template", value)
|
|
289
288
|
|
|
290
|
-
@property
|
|
289
|
+
@_builtins.property
|
|
291
290
|
@pulumi.getter(name="allowedExtensions")
|
|
292
|
-
def allowed_extensions(self) -> Optional[pulumi.Input[
|
|
291
|
+
def allowed_extensions(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
293
292
|
"""
|
|
294
293
|
Specifies a comma-separated list of extensions that certificates can have when signed.
|
|
295
294
|
"""
|
|
296
295
|
return pulumi.get(self, "allowed_extensions")
|
|
297
296
|
|
|
298
297
|
@allowed_extensions.setter
|
|
299
|
-
def allowed_extensions(self, value: Optional[pulumi.Input[
|
|
298
|
+
def allowed_extensions(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
300
299
|
pulumi.set(self, "allowed_extensions", value)
|
|
301
300
|
|
|
302
|
-
@property
|
|
301
|
+
@_builtins.property
|
|
303
302
|
@pulumi.getter(name="allowedUserKeyConfigs")
|
|
304
303
|
def allowed_user_key_configs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['SecretBackendRoleAllowedUserKeyConfigArgs']]]]:
|
|
305
304
|
"""
|
|
@@ -313,129 +312,129 @@ class SecretBackendRoleArgs:
|
|
|
313
312
|
def allowed_user_key_configs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['SecretBackendRoleAllowedUserKeyConfigArgs']]]]):
|
|
314
313
|
pulumi.set(self, "allowed_user_key_configs", value)
|
|
315
314
|
|
|
316
|
-
@property
|
|
315
|
+
@_builtins.property
|
|
317
316
|
@pulumi.getter(name="allowedUsers")
|
|
318
|
-
def allowed_users(self) -> Optional[pulumi.Input[
|
|
317
|
+
def allowed_users(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
319
318
|
"""
|
|
320
319
|
Specifies a comma-separated list of usernames that are to be allowed, only if certain usernames are to be allowed.
|
|
321
320
|
"""
|
|
322
321
|
return pulumi.get(self, "allowed_users")
|
|
323
322
|
|
|
324
323
|
@allowed_users.setter
|
|
325
|
-
def allowed_users(self, value: Optional[pulumi.Input[
|
|
324
|
+
def allowed_users(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
326
325
|
pulumi.set(self, "allowed_users", value)
|
|
327
326
|
|
|
328
|
-
@property
|
|
327
|
+
@_builtins.property
|
|
329
328
|
@pulumi.getter(name="allowedUsersTemplate")
|
|
330
|
-
def allowed_users_template(self) -> Optional[pulumi.Input[
|
|
329
|
+
def allowed_users_template(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
331
330
|
"""
|
|
332
331
|
Specifies if `allowed_users` can be declared using identity template policies. Non-templated users are also permitted.
|
|
333
332
|
"""
|
|
334
333
|
return pulumi.get(self, "allowed_users_template")
|
|
335
334
|
|
|
336
335
|
@allowed_users_template.setter
|
|
337
|
-
def allowed_users_template(self, value: Optional[pulumi.Input[
|
|
336
|
+
def allowed_users_template(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
338
337
|
pulumi.set(self, "allowed_users_template", value)
|
|
339
338
|
|
|
340
|
-
@property
|
|
339
|
+
@_builtins.property
|
|
341
340
|
@pulumi.getter(name="cidrList")
|
|
342
|
-
def cidr_list(self) -> Optional[pulumi.Input[
|
|
341
|
+
def cidr_list(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
343
342
|
"""
|
|
344
343
|
The comma-separated string of CIDR blocks for which this role is applicable.
|
|
345
344
|
"""
|
|
346
345
|
return pulumi.get(self, "cidr_list")
|
|
347
346
|
|
|
348
347
|
@cidr_list.setter
|
|
349
|
-
def cidr_list(self, value: Optional[pulumi.Input[
|
|
348
|
+
def cidr_list(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
350
349
|
pulumi.set(self, "cidr_list", value)
|
|
351
350
|
|
|
352
|
-
@property
|
|
351
|
+
@_builtins.property
|
|
353
352
|
@pulumi.getter(name="defaultCriticalOptions")
|
|
354
|
-
def default_critical_options(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[
|
|
353
|
+
def default_critical_options(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]:
|
|
355
354
|
"""
|
|
356
355
|
Specifies a map of critical options that certificates have when signed.
|
|
357
356
|
"""
|
|
358
357
|
return pulumi.get(self, "default_critical_options")
|
|
359
358
|
|
|
360
359
|
@default_critical_options.setter
|
|
361
|
-
def default_critical_options(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[
|
|
360
|
+
def default_critical_options(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]):
|
|
362
361
|
pulumi.set(self, "default_critical_options", value)
|
|
363
362
|
|
|
364
|
-
@property
|
|
363
|
+
@_builtins.property
|
|
365
364
|
@pulumi.getter(name="defaultExtensions")
|
|
366
|
-
def default_extensions(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[
|
|
365
|
+
def default_extensions(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]:
|
|
367
366
|
"""
|
|
368
367
|
Specifies a map of extensions that certificates have when signed.
|
|
369
368
|
"""
|
|
370
369
|
return pulumi.get(self, "default_extensions")
|
|
371
370
|
|
|
372
371
|
@default_extensions.setter
|
|
373
|
-
def default_extensions(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[
|
|
372
|
+
def default_extensions(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]):
|
|
374
373
|
pulumi.set(self, "default_extensions", value)
|
|
375
374
|
|
|
376
|
-
@property
|
|
375
|
+
@_builtins.property
|
|
377
376
|
@pulumi.getter(name="defaultUser")
|
|
378
|
-
def default_user(self) -> Optional[pulumi.Input[
|
|
377
|
+
def default_user(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
379
378
|
"""
|
|
380
379
|
Specifies the default username for which a credential will be generated.
|
|
381
380
|
"""
|
|
382
381
|
return pulumi.get(self, "default_user")
|
|
383
382
|
|
|
384
383
|
@default_user.setter
|
|
385
|
-
def default_user(self, value: Optional[pulumi.Input[
|
|
384
|
+
def default_user(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
386
385
|
pulumi.set(self, "default_user", value)
|
|
387
386
|
|
|
388
|
-
@property
|
|
387
|
+
@_builtins.property
|
|
389
388
|
@pulumi.getter(name="defaultUserTemplate")
|
|
390
|
-
def default_user_template(self) -> Optional[pulumi.Input[
|
|
389
|
+
def default_user_template(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
391
390
|
"""
|
|
392
391
|
If set, `default_users` can be specified using identity template values. A non-templated user is also permitted.
|
|
393
392
|
"""
|
|
394
393
|
return pulumi.get(self, "default_user_template")
|
|
395
394
|
|
|
396
395
|
@default_user_template.setter
|
|
397
|
-
def default_user_template(self, value: Optional[pulumi.Input[
|
|
396
|
+
def default_user_template(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
398
397
|
pulumi.set(self, "default_user_template", value)
|
|
399
398
|
|
|
400
|
-
@property
|
|
399
|
+
@_builtins.property
|
|
401
400
|
@pulumi.getter(name="keyIdFormat")
|
|
402
|
-
def key_id_format(self) -> Optional[pulumi.Input[
|
|
401
|
+
def key_id_format(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
403
402
|
"""
|
|
404
403
|
Specifies a custom format for the key id of a signed certificate.
|
|
405
404
|
"""
|
|
406
405
|
return pulumi.get(self, "key_id_format")
|
|
407
406
|
|
|
408
407
|
@key_id_format.setter
|
|
409
|
-
def key_id_format(self, value: Optional[pulumi.Input[
|
|
408
|
+
def key_id_format(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
410
409
|
pulumi.set(self, "key_id_format", value)
|
|
411
410
|
|
|
412
|
-
@property
|
|
411
|
+
@_builtins.property
|
|
413
412
|
@pulumi.getter(name="maxTtl")
|
|
414
|
-
def max_ttl(self) -> Optional[pulumi.Input[
|
|
413
|
+
def max_ttl(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
415
414
|
"""
|
|
416
415
|
Specifies the maximum Time To Live value.
|
|
417
416
|
"""
|
|
418
417
|
return pulumi.get(self, "max_ttl")
|
|
419
418
|
|
|
420
419
|
@max_ttl.setter
|
|
421
|
-
def max_ttl(self, value: Optional[pulumi.Input[
|
|
420
|
+
def max_ttl(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
422
421
|
pulumi.set(self, "max_ttl", value)
|
|
423
422
|
|
|
424
|
-
@property
|
|
423
|
+
@_builtins.property
|
|
425
424
|
@pulumi.getter
|
|
426
|
-
def name(self) -> Optional[pulumi.Input[
|
|
425
|
+
def name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
427
426
|
"""
|
|
428
427
|
Specifies the name of the role to create.
|
|
429
428
|
"""
|
|
430
429
|
return pulumi.get(self, "name")
|
|
431
430
|
|
|
432
431
|
@name.setter
|
|
433
|
-
def name(self, value: Optional[pulumi.Input[
|
|
432
|
+
def name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
434
433
|
pulumi.set(self, "name", value)
|
|
435
434
|
|
|
436
|
-
@property
|
|
435
|
+
@_builtins.property
|
|
437
436
|
@pulumi.getter
|
|
438
|
-
def namespace(self) -> Optional[pulumi.Input[
|
|
437
|
+
def namespace(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
439
438
|
"""
|
|
440
439
|
The namespace to provision the resource in.
|
|
441
440
|
The value should not contain leading or trailing forward slashes.
|
|
@@ -445,101 +444,101 @@ class SecretBackendRoleArgs:
|
|
|
445
444
|
return pulumi.get(self, "namespace")
|
|
446
445
|
|
|
447
446
|
@namespace.setter
|
|
448
|
-
def namespace(self, value: Optional[pulumi.Input[
|
|
447
|
+
def namespace(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
449
448
|
pulumi.set(self, "namespace", value)
|
|
450
449
|
|
|
451
|
-
@property
|
|
450
|
+
@_builtins.property
|
|
452
451
|
@pulumi.getter(name="notBeforeDuration")
|
|
453
|
-
def not_before_duration(self) -> Optional[pulumi.Input[
|
|
452
|
+
def not_before_duration(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
454
453
|
"""
|
|
455
454
|
Specifies the duration by which to backdate the ValidAfter property. Uses duration format strings.
|
|
456
455
|
"""
|
|
457
456
|
return pulumi.get(self, "not_before_duration")
|
|
458
457
|
|
|
459
458
|
@not_before_duration.setter
|
|
460
|
-
def not_before_duration(self, value: Optional[pulumi.Input[
|
|
459
|
+
def not_before_duration(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
461
460
|
pulumi.set(self, "not_before_duration", value)
|
|
462
461
|
|
|
463
|
-
@property
|
|
462
|
+
@_builtins.property
|
|
464
463
|
@pulumi.getter
|
|
465
|
-
def ttl(self) -> Optional[pulumi.Input[
|
|
464
|
+
def ttl(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
466
465
|
"""
|
|
467
466
|
Specifies the Time To Live value.
|
|
468
467
|
"""
|
|
469
468
|
return pulumi.get(self, "ttl")
|
|
470
469
|
|
|
471
470
|
@ttl.setter
|
|
472
|
-
def ttl(self, value: Optional[pulumi.Input[
|
|
471
|
+
def ttl(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
473
472
|
pulumi.set(self, "ttl", value)
|
|
474
473
|
|
|
475
474
|
|
|
476
475
|
@pulumi.input_type
|
|
477
476
|
class _SecretBackendRoleState:
|
|
478
477
|
def __init__(__self__, *,
|
|
479
|
-
algorithm_signer: Optional[pulumi.Input[
|
|
480
|
-
allow_bare_domains: Optional[pulumi.Input[
|
|
481
|
-
allow_empty_principals: Optional[pulumi.Input[
|
|
482
|
-
allow_host_certificates: Optional[pulumi.Input[
|
|
483
|
-
allow_subdomains: Optional[pulumi.Input[
|
|
484
|
-
allow_user_certificates: Optional[pulumi.Input[
|
|
485
|
-
allow_user_key_ids: Optional[pulumi.Input[
|
|
486
|
-
allowed_critical_options: Optional[pulumi.Input[
|
|
487
|
-
allowed_domains: Optional[pulumi.Input[
|
|
488
|
-
allowed_domains_template: Optional[pulumi.Input[
|
|
489
|
-
allowed_extensions: Optional[pulumi.Input[
|
|
478
|
+
algorithm_signer: Optional[pulumi.Input[_builtins.str]] = None,
|
|
479
|
+
allow_bare_domains: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
480
|
+
allow_empty_principals: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
481
|
+
allow_host_certificates: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
482
|
+
allow_subdomains: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
483
|
+
allow_user_certificates: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
484
|
+
allow_user_key_ids: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
485
|
+
allowed_critical_options: Optional[pulumi.Input[_builtins.str]] = None,
|
|
486
|
+
allowed_domains: Optional[pulumi.Input[_builtins.str]] = None,
|
|
487
|
+
allowed_domains_template: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
488
|
+
allowed_extensions: Optional[pulumi.Input[_builtins.str]] = None,
|
|
490
489
|
allowed_user_key_configs: Optional[pulumi.Input[Sequence[pulumi.Input['SecretBackendRoleAllowedUserKeyConfigArgs']]]] = None,
|
|
491
|
-
allowed_users: Optional[pulumi.Input[
|
|
492
|
-
allowed_users_template: Optional[pulumi.Input[
|
|
493
|
-
backend: Optional[pulumi.Input[
|
|
494
|
-
cidr_list: Optional[pulumi.Input[
|
|
495
|
-
default_critical_options: Optional[pulumi.Input[Mapping[str, pulumi.Input[
|
|
496
|
-
default_extensions: Optional[pulumi.Input[Mapping[str, pulumi.Input[
|
|
497
|
-
default_user: Optional[pulumi.Input[
|
|
498
|
-
default_user_template: Optional[pulumi.Input[
|
|
499
|
-
key_id_format: Optional[pulumi.Input[
|
|
500
|
-
key_type: Optional[pulumi.Input[
|
|
501
|
-
max_ttl: Optional[pulumi.Input[
|
|
502
|
-
name: Optional[pulumi.Input[
|
|
503
|
-
namespace: Optional[pulumi.Input[
|
|
504
|
-
not_before_duration: Optional[pulumi.Input[
|
|
505
|
-
ttl: Optional[pulumi.Input[
|
|
490
|
+
allowed_users: Optional[pulumi.Input[_builtins.str]] = None,
|
|
491
|
+
allowed_users_template: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
492
|
+
backend: Optional[pulumi.Input[_builtins.str]] = None,
|
|
493
|
+
cidr_list: Optional[pulumi.Input[_builtins.str]] = None,
|
|
494
|
+
default_critical_options: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
|
|
495
|
+
default_extensions: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
|
|
496
|
+
default_user: Optional[pulumi.Input[_builtins.str]] = None,
|
|
497
|
+
default_user_template: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
498
|
+
key_id_format: Optional[pulumi.Input[_builtins.str]] = None,
|
|
499
|
+
key_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
500
|
+
max_ttl: Optional[pulumi.Input[_builtins.str]] = None,
|
|
501
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
502
|
+
namespace: Optional[pulumi.Input[_builtins.str]] = None,
|
|
503
|
+
not_before_duration: Optional[pulumi.Input[_builtins.str]] = None,
|
|
504
|
+
ttl: Optional[pulumi.Input[_builtins.str]] = None):
|
|
506
505
|
"""
|
|
507
506
|
Input properties used for looking up and filtering SecretBackendRole resources.
|
|
508
|
-
:param pulumi.Input[
|
|
509
|
-
:param pulumi.Input[
|
|
510
|
-
:param pulumi.Input[
|
|
507
|
+
:param pulumi.Input[_builtins.str] algorithm_signer: When supplied, this value specifies a signing algorithm for the key. Possible values: ssh-rsa, rsa-sha2-256, rsa-sha2-512.
|
|
508
|
+
:param pulumi.Input[_builtins.bool] allow_bare_domains: Specifies if host certificates that are requested are allowed to use the base domains listed in `allowed_domains`.
|
|
509
|
+
:param pulumi.Input[_builtins.bool] allow_empty_principals: Allow signing certificates with no
|
|
511
510
|
valid principals (e.g. any valid principal). For backwards compatibility
|
|
512
511
|
only. The default of false is highly recommended.
|
|
513
|
-
:param pulumi.Input[
|
|
514
|
-
:param pulumi.Input[
|
|
515
|
-
:param pulumi.Input[
|
|
516
|
-
:param pulumi.Input[
|
|
517
|
-
:param pulumi.Input[
|
|
518
|
-
:param pulumi.Input[
|
|
519
|
-
:param pulumi.Input[
|
|
512
|
+
:param pulumi.Input[_builtins.bool] allow_host_certificates: Specifies if certificates are allowed to be signed for use as a 'host'.
|
|
513
|
+
:param pulumi.Input[_builtins.bool] allow_subdomains: Specifies if host certificates that are requested are allowed to be subdomains of those listed in `allowed_domains`.
|
|
514
|
+
:param pulumi.Input[_builtins.bool] allow_user_certificates: Specifies if certificates are allowed to be signed for use as a 'user'.
|
|
515
|
+
:param pulumi.Input[_builtins.bool] allow_user_key_ids: Specifies if users can override the key ID for a signed certificate with the `key_id` field.
|
|
516
|
+
:param pulumi.Input[_builtins.str] allowed_critical_options: Specifies a comma-separated list of critical options that certificates can have when signed.
|
|
517
|
+
:param pulumi.Input[_builtins.str] allowed_domains: The list of domains for which a client can request a host certificate.
|
|
518
|
+
:param pulumi.Input[_builtins.bool] allowed_domains_template: Specifies if `allowed_domains` can be declared using
|
|
520
519
|
identity template policies. Non-templated domains are also permitted.
|
|
521
|
-
:param pulumi.Input[
|
|
520
|
+
:param pulumi.Input[_builtins.str] allowed_extensions: Specifies a comma-separated list of extensions that certificates can have when signed.
|
|
522
521
|
:param pulumi.Input[Sequence[pulumi.Input['SecretBackendRoleAllowedUserKeyConfigArgs']]] allowed_user_key_configs: Set of configuration blocks to define allowed
|
|
523
522
|
user key configuration, like key type and their lengths. Can be specified multiple times.
|
|
524
523
|
*See Configuration-Options for more info*
|
|
525
|
-
:param pulumi.Input[
|
|
526
|
-
:param pulumi.Input[
|
|
527
|
-
:param pulumi.Input[
|
|
528
|
-
:param pulumi.Input[
|
|
529
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[
|
|
530
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[
|
|
531
|
-
:param pulumi.Input[
|
|
532
|
-
:param pulumi.Input[
|
|
533
|
-
:param pulumi.Input[
|
|
534
|
-
:param pulumi.Input[
|
|
535
|
-
:param pulumi.Input[
|
|
536
|
-
:param pulumi.Input[
|
|
537
|
-
:param pulumi.Input[
|
|
524
|
+
:param pulumi.Input[_builtins.str] allowed_users: Specifies a comma-separated list of usernames that are to be allowed, only if certain usernames are to be allowed.
|
|
525
|
+
:param pulumi.Input[_builtins.bool] allowed_users_template: Specifies if `allowed_users` can be declared using identity template policies. Non-templated users are also permitted.
|
|
526
|
+
:param pulumi.Input[_builtins.str] backend: The path where the SSH secret backend is mounted.
|
|
527
|
+
:param pulumi.Input[_builtins.str] cidr_list: The comma-separated string of CIDR blocks for which this role is applicable.
|
|
528
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] default_critical_options: Specifies a map of critical options that certificates have when signed.
|
|
529
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] default_extensions: Specifies a map of extensions that certificates have when signed.
|
|
530
|
+
:param pulumi.Input[_builtins.str] default_user: Specifies the default username for which a credential will be generated.
|
|
531
|
+
:param pulumi.Input[_builtins.bool] default_user_template: If set, `default_users` can be specified using identity template values. A non-templated user is also permitted.
|
|
532
|
+
:param pulumi.Input[_builtins.str] key_id_format: Specifies a custom format for the key id of a signed certificate.
|
|
533
|
+
:param pulumi.Input[_builtins.str] key_type: Specifies the type of credentials generated by this role. This can be either `otp`, `dynamic` or `ca`.
|
|
534
|
+
:param pulumi.Input[_builtins.str] max_ttl: Specifies the maximum Time To Live value.
|
|
535
|
+
:param pulumi.Input[_builtins.str] name: Specifies the name of the role to create.
|
|
536
|
+
:param pulumi.Input[_builtins.str] namespace: The namespace to provision the resource in.
|
|
538
537
|
The value should not contain leading or trailing forward slashes.
|
|
539
538
|
The `namespace` is always relative to the provider's configured [namespace](https://www.terraform.io/docs/providers/vault/index.html#namespace).
|
|
540
539
|
*Available only for Vault Enterprise*.
|
|
541
|
-
:param pulumi.Input[
|
|
542
|
-
:param pulumi.Input[
|
|
540
|
+
:param pulumi.Input[_builtins.str] not_before_duration: Specifies the duration by which to backdate the ValidAfter property. Uses duration format strings.
|
|
541
|
+
:param pulumi.Input[_builtins.str] ttl: Specifies the Time To Live value.
|
|
543
542
|
"""
|
|
544
543
|
if algorithm_signer is not None:
|
|
545
544
|
pulumi.set(__self__, "algorithm_signer", algorithm_signer)
|
|
@@ -596,33 +595,33 @@ class _SecretBackendRoleState:
|
|
|
596
595
|
if ttl is not None:
|
|
597
596
|
pulumi.set(__self__, "ttl", ttl)
|
|
598
597
|
|
|
599
|
-
@property
|
|
598
|
+
@_builtins.property
|
|
600
599
|
@pulumi.getter(name="algorithmSigner")
|
|
601
|
-
def algorithm_signer(self) -> Optional[pulumi.Input[
|
|
600
|
+
def algorithm_signer(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
602
601
|
"""
|
|
603
602
|
When supplied, this value specifies a signing algorithm for the key. Possible values: ssh-rsa, rsa-sha2-256, rsa-sha2-512.
|
|
604
603
|
"""
|
|
605
604
|
return pulumi.get(self, "algorithm_signer")
|
|
606
605
|
|
|
607
606
|
@algorithm_signer.setter
|
|
608
|
-
def algorithm_signer(self, value: Optional[pulumi.Input[
|
|
607
|
+
def algorithm_signer(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
609
608
|
pulumi.set(self, "algorithm_signer", value)
|
|
610
609
|
|
|
611
|
-
@property
|
|
610
|
+
@_builtins.property
|
|
612
611
|
@pulumi.getter(name="allowBareDomains")
|
|
613
|
-
def allow_bare_domains(self) -> Optional[pulumi.Input[
|
|
612
|
+
def allow_bare_domains(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
614
613
|
"""
|
|
615
614
|
Specifies if host certificates that are requested are allowed to use the base domains listed in `allowed_domains`.
|
|
616
615
|
"""
|
|
617
616
|
return pulumi.get(self, "allow_bare_domains")
|
|
618
617
|
|
|
619
618
|
@allow_bare_domains.setter
|
|
620
|
-
def allow_bare_domains(self, value: Optional[pulumi.Input[
|
|
619
|
+
def allow_bare_domains(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
621
620
|
pulumi.set(self, "allow_bare_domains", value)
|
|
622
621
|
|
|
623
|
-
@property
|
|
622
|
+
@_builtins.property
|
|
624
623
|
@pulumi.getter(name="allowEmptyPrincipals")
|
|
625
|
-
def allow_empty_principals(self) -> Optional[pulumi.Input[
|
|
624
|
+
def allow_empty_principals(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
626
625
|
"""
|
|
627
626
|
Allow signing certificates with no
|
|
628
627
|
valid principals (e.g. any valid principal). For backwards compatibility
|
|
@@ -631,84 +630,84 @@ class _SecretBackendRoleState:
|
|
|
631
630
|
return pulumi.get(self, "allow_empty_principals")
|
|
632
631
|
|
|
633
632
|
@allow_empty_principals.setter
|
|
634
|
-
def allow_empty_principals(self, value: Optional[pulumi.Input[
|
|
633
|
+
def allow_empty_principals(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
635
634
|
pulumi.set(self, "allow_empty_principals", value)
|
|
636
635
|
|
|
637
|
-
@property
|
|
636
|
+
@_builtins.property
|
|
638
637
|
@pulumi.getter(name="allowHostCertificates")
|
|
639
|
-
def allow_host_certificates(self) -> Optional[pulumi.Input[
|
|
638
|
+
def allow_host_certificates(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
640
639
|
"""
|
|
641
640
|
Specifies if certificates are allowed to be signed for use as a 'host'.
|
|
642
641
|
"""
|
|
643
642
|
return pulumi.get(self, "allow_host_certificates")
|
|
644
643
|
|
|
645
644
|
@allow_host_certificates.setter
|
|
646
|
-
def allow_host_certificates(self, value: Optional[pulumi.Input[
|
|
645
|
+
def allow_host_certificates(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
647
646
|
pulumi.set(self, "allow_host_certificates", value)
|
|
648
647
|
|
|
649
|
-
@property
|
|
648
|
+
@_builtins.property
|
|
650
649
|
@pulumi.getter(name="allowSubdomains")
|
|
651
|
-
def allow_subdomains(self) -> Optional[pulumi.Input[
|
|
650
|
+
def allow_subdomains(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
652
651
|
"""
|
|
653
652
|
Specifies if host certificates that are requested are allowed to be subdomains of those listed in `allowed_domains`.
|
|
654
653
|
"""
|
|
655
654
|
return pulumi.get(self, "allow_subdomains")
|
|
656
655
|
|
|
657
656
|
@allow_subdomains.setter
|
|
658
|
-
def allow_subdomains(self, value: Optional[pulumi.Input[
|
|
657
|
+
def allow_subdomains(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
659
658
|
pulumi.set(self, "allow_subdomains", value)
|
|
660
659
|
|
|
661
|
-
@property
|
|
660
|
+
@_builtins.property
|
|
662
661
|
@pulumi.getter(name="allowUserCertificates")
|
|
663
|
-
def allow_user_certificates(self) -> Optional[pulumi.Input[
|
|
662
|
+
def allow_user_certificates(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
664
663
|
"""
|
|
665
664
|
Specifies if certificates are allowed to be signed for use as a 'user'.
|
|
666
665
|
"""
|
|
667
666
|
return pulumi.get(self, "allow_user_certificates")
|
|
668
667
|
|
|
669
668
|
@allow_user_certificates.setter
|
|
670
|
-
def allow_user_certificates(self, value: Optional[pulumi.Input[
|
|
669
|
+
def allow_user_certificates(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
671
670
|
pulumi.set(self, "allow_user_certificates", value)
|
|
672
671
|
|
|
673
|
-
@property
|
|
672
|
+
@_builtins.property
|
|
674
673
|
@pulumi.getter(name="allowUserKeyIds")
|
|
675
|
-
def allow_user_key_ids(self) -> Optional[pulumi.Input[
|
|
674
|
+
def allow_user_key_ids(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
676
675
|
"""
|
|
677
676
|
Specifies if users can override the key ID for a signed certificate with the `key_id` field.
|
|
678
677
|
"""
|
|
679
678
|
return pulumi.get(self, "allow_user_key_ids")
|
|
680
679
|
|
|
681
680
|
@allow_user_key_ids.setter
|
|
682
|
-
def allow_user_key_ids(self, value: Optional[pulumi.Input[
|
|
681
|
+
def allow_user_key_ids(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
683
682
|
pulumi.set(self, "allow_user_key_ids", value)
|
|
684
683
|
|
|
685
|
-
@property
|
|
684
|
+
@_builtins.property
|
|
686
685
|
@pulumi.getter(name="allowedCriticalOptions")
|
|
687
|
-
def allowed_critical_options(self) -> Optional[pulumi.Input[
|
|
686
|
+
def allowed_critical_options(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
688
687
|
"""
|
|
689
688
|
Specifies a comma-separated list of critical options that certificates can have when signed.
|
|
690
689
|
"""
|
|
691
690
|
return pulumi.get(self, "allowed_critical_options")
|
|
692
691
|
|
|
693
692
|
@allowed_critical_options.setter
|
|
694
|
-
def allowed_critical_options(self, value: Optional[pulumi.Input[
|
|
693
|
+
def allowed_critical_options(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
695
694
|
pulumi.set(self, "allowed_critical_options", value)
|
|
696
695
|
|
|
697
|
-
@property
|
|
696
|
+
@_builtins.property
|
|
698
697
|
@pulumi.getter(name="allowedDomains")
|
|
699
|
-
def allowed_domains(self) -> Optional[pulumi.Input[
|
|
698
|
+
def allowed_domains(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
700
699
|
"""
|
|
701
700
|
The list of domains for which a client can request a host certificate.
|
|
702
701
|
"""
|
|
703
702
|
return pulumi.get(self, "allowed_domains")
|
|
704
703
|
|
|
705
704
|
@allowed_domains.setter
|
|
706
|
-
def allowed_domains(self, value: Optional[pulumi.Input[
|
|
705
|
+
def allowed_domains(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
707
706
|
pulumi.set(self, "allowed_domains", value)
|
|
708
707
|
|
|
709
|
-
@property
|
|
708
|
+
@_builtins.property
|
|
710
709
|
@pulumi.getter(name="allowedDomainsTemplate")
|
|
711
|
-
def allowed_domains_template(self) -> Optional[pulumi.Input[
|
|
710
|
+
def allowed_domains_template(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
712
711
|
"""
|
|
713
712
|
Specifies if `allowed_domains` can be declared using
|
|
714
713
|
identity template policies. Non-templated domains are also permitted.
|
|
@@ -716,22 +715,22 @@ class _SecretBackendRoleState:
|
|
|
716
715
|
return pulumi.get(self, "allowed_domains_template")
|
|
717
716
|
|
|
718
717
|
@allowed_domains_template.setter
|
|
719
|
-
def allowed_domains_template(self, value: Optional[pulumi.Input[
|
|
718
|
+
def allowed_domains_template(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
720
719
|
pulumi.set(self, "allowed_domains_template", value)
|
|
721
720
|
|
|
722
|
-
@property
|
|
721
|
+
@_builtins.property
|
|
723
722
|
@pulumi.getter(name="allowedExtensions")
|
|
724
|
-
def allowed_extensions(self) -> Optional[pulumi.Input[
|
|
723
|
+
def allowed_extensions(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
725
724
|
"""
|
|
726
725
|
Specifies a comma-separated list of extensions that certificates can have when signed.
|
|
727
726
|
"""
|
|
728
727
|
return pulumi.get(self, "allowed_extensions")
|
|
729
728
|
|
|
730
729
|
@allowed_extensions.setter
|
|
731
|
-
def allowed_extensions(self, value: Optional[pulumi.Input[
|
|
730
|
+
def allowed_extensions(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
732
731
|
pulumi.set(self, "allowed_extensions", value)
|
|
733
732
|
|
|
734
|
-
@property
|
|
733
|
+
@_builtins.property
|
|
735
734
|
@pulumi.getter(name="allowedUserKeyConfigs")
|
|
736
735
|
def allowed_user_key_configs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['SecretBackendRoleAllowedUserKeyConfigArgs']]]]:
|
|
737
736
|
"""
|
|
@@ -745,153 +744,153 @@ class _SecretBackendRoleState:
|
|
|
745
744
|
def allowed_user_key_configs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['SecretBackendRoleAllowedUserKeyConfigArgs']]]]):
|
|
746
745
|
pulumi.set(self, "allowed_user_key_configs", value)
|
|
747
746
|
|
|
748
|
-
@property
|
|
747
|
+
@_builtins.property
|
|
749
748
|
@pulumi.getter(name="allowedUsers")
|
|
750
|
-
def allowed_users(self) -> Optional[pulumi.Input[
|
|
749
|
+
def allowed_users(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
751
750
|
"""
|
|
752
751
|
Specifies a comma-separated list of usernames that are to be allowed, only if certain usernames are to be allowed.
|
|
753
752
|
"""
|
|
754
753
|
return pulumi.get(self, "allowed_users")
|
|
755
754
|
|
|
756
755
|
@allowed_users.setter
|
|
757
|
-
def allowed_users(self, value: Optional[pulumi.Input[
|
|
756
|
+
def allowed_users(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
758
757
|
pulumi.set(self, "allowed_users", value)
|
|
759
758
|
|
|
760
|
-
@property
|
|
759
|
+
@_builtins.property
|
|
761
760
|
@pulumi.getter(name="allowedUsersTemplate")
|
|
762
|
-
def allowed_users_template(self) -> Optional[pulumi.Input[
|
|
761
|
+
def allowed_users_template(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
763
762
|
"""
|
|
764
763
|
Specifies if `allowed_users` can be declared using identity template policies. Non-templated users are also permitted.
|
|
765
764
|
"""
|
|
766
765
|
return pulumi.get(self, "allowed_users_template")
|
|
767
766
|
|
|
768
767
|
@allowed_users_template.setter
|
|
769
|
-
def allowed_users_template(self, value: Optional[pulumi.Input[
|
|
768
|
+
def allowed_users_template(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
770
769
|
pulumi.set(self, "allowed_users_template", value)
|
|
771
770
|
|
|
772
|
-
@property
|
|
771
|
+
@_builtins.property
|
|
773
772
|
@pulumi.getter
|
|
774
|
-
def backend(self) -> Optional[pulumi.Input[
|
|
773
|
+
def backend(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
775
774
|
"""
|
|
776
775
|
The path where the SSH secret backend is mounted.
|
|
777
776
|
"""
|
|
778
777
|
return pulumi.get(self, "backend")
|
|
779
778
|
|
|
780
779
|
@backend.setter
|
|
781
|
-
def backend(self, value: Optional[pulumi.Input[
|
|
780
|
+
def backend(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
782
781
|
pulumi.set(self, "backend", value)
|
|
783
782
|
|
|
784
|
-
@property
|
|
783
|
+
@_builtins.property
|
|
785
784
|
@pulumi.getter(name="cidrList")
|
|
786
|
-
def cidr_list(self) -> Optional[pulumi.Input[
|
|
785
|
+
def cidr_list(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
787
786
|
"""
|
|
788
787
|
The comma-separated string of CIDR blocks for which this role is applicable.
|
|
789
788
|
"""
|
|
790
789
|
return pulumi.get(self, "cidr_list")
|
|
791
790
|
|
|
792
791
|
@cidr_list.setter
|
|
793
|
-
def cidr_list(self, value: Optional[pulumi.Input[
|
|
792
|
+
def cidr_list(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
794
793
|
pulumi.set(self, "cidr_list", value)
|
|
795
794
|
|
|
796
|
-
@property
|
|
795
|
+
@_builtins.property
|
|
797
796
|
@pulumi.getter(name="defaultCriticalOptions")
|
|
798
|
-
def default_critical_options(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[
|
|
797
|
+
def default_critical_options(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]:
|
|
799
798
|
"""
|
|
800
799
|
Specifies a map of critical options that certificates have when signed.
|
|
801
800
|
"""
|
|
802
801
|
return pulumi.get(self, "default_critical_options")
|
|
803
802
|
|
|
804
803
|
@default_critical_options.setter
|
|
805
|
-
def default_critical_options(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[
|
|
804
|
+
def default_critical_options(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]):
|
|
806
805
|
pulumi.set(self, "default_critical_options", value)
|
|
807
806
|
|
|
808
|
-
@property
|
|
807
|
+
@_builtins.property
|
|
809
808
|
@pulumi.getter(name="defaultExtensions")
|
|
810
|
-
def default_extensions(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[
|
|
809
|
+
def default_extensions(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]:
|
|
811
810
|
"""
|
|
812
811
|
Specifies a map of extensions that certificates have when signed.
|
|
813
812
|
"""
|
|
814
813
|
return pulumi.get(self, "default_extensions")
|
|
815
814
|
|
|
816
815
|
@default_extensions.setter
|
|
817
|
-
def default_extensions(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[
|
|
816
|
+
def default_extensions(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]):
|
|
818
817
|
pulumi.set(self, "default_extensions", value)
|
|
819
818
|
|
|
820
|
-
@property
|
|
819
|
+
@_builtins.property
|
|
821
820
|
@pulumi.getter(name="defaultUser")
|
|
822
|
-
def default_user(self) -> Optional[pulumi.Input[
|
|
821
|
+
def default_user(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
823
822
|
"""
|
|
824
823
|
Specifies the default username for which a credential will be generated.
|
|
825
824
|
"""
|
|
826
825
|
return pulumi.get(self, "default_user")
|
|
827
826
|
|
|
828
827
|
@default_user.setter
|
|
829
|
-
def default_user(self, value: Optional[pulumi.Input[
|
|
828
|
+
def default_user(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
830
829
|
pulumi.set(self, "default_user", value)
|
|
831
830
|
|
|
832
|
-
@property
|
|
831
|
+
@_builtins.property
|
|
833
832
|
@pulumi.getter(name="defaultUserTemplate")
|
|
834
|
-
def default_user_template(self) -> Optional[pulumi.Input[
|
|
833
|
+
def default_user_template(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
835
834
|
"""
|
|
836
835
|
If set, `default_users` can be specified using identity template values. A non-templated user is also permitted.
|
|
837
836
|
"""
|
|
838
837
|
return pulumi.get(self, "default_user_template")
|
|
839
838
|
|
|
840
839
|
@default_user_template.setter
|
|
841
|
-
def default_user_template(self, value: Optional[pulumi.Input[
|
|
840
|
+
def default_user_template(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
842
841
|
pulumi.set(self, "default_user_template", value)
|
|
843
842
|
|
|
844
|
-
@property
|
|
843
|
+
@_builtins.property
|
|
845
844
|
@pulumi.getter(name="keyIdFormat")
|
|
846
|
-
def key_id_format(self) -> Optional[pulumi.Input[
|
|
845
|
+
def key_id_format(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
847
846
|
"""
|
|
848
847
|
Specifies a custom format for the key id of a signed certificate.
|
|
849
848
|
"""
|
|
850
849
|
return pulumi.get(self, "key_id_format")
|
|
851
850
|
|
|
852
851
|
@key_id_format.setter
|
|
853
|
-
def key_id_format(self, value: Optional[pulumi.Input[
|
|
852
|
+
def key_id_format(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
854
853
|
pulumi.set(self, "key_id_format", value)
|
|
855
854
|
|
|
856
|
-
@property
|
|
855
|
+
@_builtins.property
|
|
857
856
|
@pulumi.getter(name="keyType")
|
|
858
|
-
def key_type(self) -> Optional[pulumi.Input[
|
|
857
|
+
def key_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
859
858
|
"""
|
|
860
859
|
Specifies the type of credentials generated by this role. This can be either `otp`, `dynamic` or `ca`.
|
|
861
860
|
"""
|
|
862
861
|
return pulumi.get(self, "key_type")
|
|
863
862
|
|
|
864
863
|
@key_type.setter
|
|
865
|
-
def key_type(self, value: Optional[pulumi.Input[
|
|
864
|
+
def key_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
866
865
|
pulumi.set(self, "key_type", value)
|
|
867
866
|
|
|
868
|
-
@property
|
|
867
|
+
@_builtins.property
|
|
869
868
|
@pulumi.getter(name="maxTtl")
|
|
870
|
-
def max_ttl(self) -> Optional[pulumi.Input[
|
|
869
|
+
def max_ttl(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
871
870
|
"""
|
|
872
871
|
Specifies the maximum Time To Live value.
|
|
873
872
|
"""
|
|
874
873
|
return pulumi.get(self, "max_ttl")
|
|
875
874
|
|
|
876
875
|
@max_ttl.setter
|
|
877
|
-
def max_ttl(self, value: Optional[pulumi.Input[
|
|
876
|
+
def max_ttl(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
878
877
|
pulumi.set(self, "max_ttl", value)
|
|
879
878
|
|
|
880
|
-
@property
|
|
879
|
+
@_builtins.property
|
|
881
880
|
@pulumi.getter
|
|
882
|
-
def name(self) -> Optional[pulumi.Input[
|
|
881
|
+
def name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
883
882
|
"""
|
|
884
883
|
Specifies the name of the role to create.
|
|
885
884
|
"""
|
|
886
885
|
return pulumi.get(self, "name")
|
|
887
886
|
|
|
888
887
|
@name.setter
|
|
889
|
-
def name(self, value: Optional[pulumi.Input[
|
|
888
|
+
def name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
890
889
|
pulumi.set(self, "name", value)
|
|
891
890
|
|
|
892
|
-
@property
|
|
891
|
+
@_builtins.property
|
|
893
892
|
@pulumi.getter
|
|
894
|
-
def namespace(self) -> Optional[pulumi.Input[
|
|
893
|
+
def namespace(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
895
894
|
"""
|
|
896
895
|
The namespace to provision the resource in.
|
|
897
896
|
The value should not contain leading or trailing forward slashes.
|
|
@@ -901,31 +900,31 @@ class _SecretBackendRoleState:
|
|
|
901
900
|
return pulumi.get(self, "namespace")
|
|
902
901
|
|
|
903
902
|
@namespace.setter
|
|
904
|
-
def namespace(self, value: Optional[pulumi.Input[
|
|
903
|
+
def namespace(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
905
904
|
pulumi.set(self, "namespace", value)
|
|
906
905
|
|
|
907
|
-
@property
|
|
906
|
+
@_builtins.property
|
|
908
907
|
@pulumi.getter(name="notBeforeDuration")
|
|
909
|
-
def not_before_duration(self) -> Optional[pulumi.Input[
|
|
908
|
+
def not_before_duration(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
910
909
|
"""
|
|
911
910
|
Specifies the duration by which to backdate the ValidAfter property. Uses duration format strings.
|
|
912
911
|
"""
|
|
913
912
|
return pulumi.get(self, "not_before_duration")
|
|
914
913
|
|
|
915
914
|
@not_before_duration.setter
|
|
916
|
-
def not_before_duration(self, value: Optional[pulumi.Input[
|
|
915
|
+
def not_before_duration(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
917
916
|
pulumi.set(self, "not_before_duration", value)
|
|
918
917
|
|
|
919
|
-
@property
|
|
918
|
+
@_builtins.property
|
|
920
919
|
@pulumi.getter
|
|
921
|
-
def ttl(self) -> Optional[pulumi.Input[
|
|
920
|
+
def ttl(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
922
921
|
"""
|
|
923
922
|
Specifies the Time To Live value.
|
|
924
923
|
"""
|
|
925
924
|
return pulumi.get(self, "ttl")
|
|
926
925
|
|
|
927
926
|
@ttl.setter
|
|
928
|
-
def ttl(self, value: Optional[pulumi.Input[
|
|
927
|
+
def ttl(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
929
928
|
pulumi.set(self, "ttl", value)
|
|
930
929
|
|
|
931
930
|
|
|
@@ -935,33 +934,33 @@ class SecretBackendRole(pulumi.CustomResource):
|
|
|
935
934
|
def __init__(__self__,
|
|
936
935
|
resource_name: str,
|
|
937
936
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
938
|
-
algorithm_signer: Optional[pulumi.Input[
|
|
939
|
-
allow_bare_domains: Optional[pulumi.Input[
|
|
940
|
-
allow_empty_principals: Optional[pulumi.Input[
|
|
941
|
-
allow_host_certificates: Optional[pulumi.Input[
|
|
942
|
-
allow_subdomains: Optional[pulumi.Input[
|
|
943
|
-
allow_user_certificates: Optional[pulumi.Input[
|
|
944
|
-
allow_user_key_ids: Optional[pulumi.Input[
|
|
945
|
-
allowed_critical_options: Optional[pulumi.Input[
|
|
946
|
-
allowed_domains: Optional[pulumi.Input[
|
|
947
|
-
allowed_domains_template: Optional[pulumi.Input[
|
|
948
|
-
allowed_extensions: Optional[pulumi.Input[
|
|
937
|
+
algorithm_signer: Optional[pulumi.Input[_builtins.str]] = None,
|
|
938
|
+
allow_bare_domains: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
939
|
+
allow_empty_principals: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
940
|
+
allow_host_certificates: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
941
|
+
allow_subdomains: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
942
|
+
allow_user_certificates: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
943
|
+
allow_user_key_ids: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
944
|
+
allowed_critical_options: Optional[pulumi.Input[_builtins.str]] = None,
|
|
945
|
+
allowed_domains: Optional[pulumi.Input[_builtins.str]] = None,
|
|
946
|
+
allowed_domains_template: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
947
|
+
allowed_extensions: Optional[pulumi.Input[_builtins.str]] = None,
|
|
949
948
|
allowed_user_key_configs: Optional[pulumi.Input[Sequence[pulumi.Input[Union['SecretBackendRoleAllowedUserKeyConfigArgs', 'SecretBackendRoleAllowedUserKeyConfigArgsDict']]]]] = None,
|
|
950
|
-
allowed_users: Optional[pulumi.Input[
|
|
951
|
-
allowed_users_template: Optional[pulumi.Input[
|
|
952
|
-
backend: Optional[pulumi.Input[
|
|
953
|
-
cidr_list: Optional[pulumi.Input[
|
|
954
|
-
default_critical_options: Optional[pulumi.Input[Mapping[str, pulumi.Input[
|
|
955
|
-
default_extensions: Optional[pulumi.Input[Mapping[str, pulumi.Input[
|
|
956
|
-
default_user: Optional[pulumi.Input[
|
|
957
|
-
default_user_template: Optional[pulumi.Input[
|
|
958
|
-
key_id_format: Optional[pulumi.Input[
|
|
959
|
-
key_type: Optional[pulumi.Input[
|
|
960
|
-
max_ttl: Optional[pulumi.Input[
|
|
961
|
-
name: Optional[pulumi.Input[
|
|
962
|
-
namespace: Optional[pulumi.Input[
|
|
963
|
-
not_before_duration: Optional[pulumi.Input[
|
|
964
|
-
ttl: Optional[pulumi.Input[
|
|
949
|
+
allowed_users: Optional[pulumi.Input[_builtins.str]] = None,
|
|
950
|
+
allowed_users_template: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
951
|
+
backend: Optional[pulumi.Input[_builtins.str]] = None,
|
|
952
|
+
cidr_list: Optional[pulumi.Input[_builtins.str]] = None,
|
|
953
|
+
default_critical_options: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
|
|
954
|
+
default_extensions: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
|
|
955
|
+
default_user: Optional[pulumi.Input[_builtins.str]] = None,
|
|
956
|
+
default_user_template: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
957
|
+
key_id_format: Optional[pulumi.Input[_builtins.str]] = None,
|
|
958
|
+
key_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
959
|
+
max_ttl: Optional[pulumi.Input[_builtins.str]] = None,
|
|
960
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
961
|
+
namespace: Optional[pulumi.Input[_builtins.str]] = None,
|
|
962
|
+
not_before_duration: Optional[pulumi.Input[_builtins.str]] = None,
|
|
963
|
+
ttl: Optional[pulumi.Input[_builtins.str]] = None,
|
|
965
964
|
__props__=None):
|
|
966
965
|
"""
|
|
967
966
|
Provides a resource to manage roles in an SSH secret backend
|
|
@@ -998,41 +997,41 @@ class SecretBackendRole(pulumi.CustomResource):
|
|
|
998
997
|
|
|
999
998
|
:param str resource_name: The name of the resource.
|
|
1000
999
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
1001
|
-
:param pulumi.Input[
|
|
1002
|
-
:param pulumi.Input[
|
|
1003
|
-
:param pulumi.Input[
|
|
1000
|
+
:param pulumi.Input[_builtins.str] algorithm_signer: When supplied, this value specifies a signing algorithm for the key. Possible values: ssh-rsa, rsa-sha2-256, rsa-sha2-512.
|
|
1001
|
+
:param pulumi.Input[_builtins.bool] allow_bare_domains: Specifies if host certificates that are requested are allowed to use the base domains listed in `allowed_domains`.
|
|
1002
|
+
:param pulumi.Input[_builtins.bool] allow_empty_principals: Allow signing certificates with no
|
|
1004
1003
|
valid principals (e.g. any valid principal). For backwards compatibility
|
|
1005
1004
|
only. The default of false is highly recommended.
|
|
1006
|
-
:param pulumi.Input[
|
|
1007
|
-
:param pulumi.Input[
|
|
1008
|
-
:param pulumi.Input[
|
|
1009
|
-
:param pulumi.Input[
|
|
1010
|
-
:param pulumi.Input[
|
|
1011
|
-
:param pulumi.Input[
|
|
1012
|
-
:param pulumi.Input[
|
|
1005
|
+
:param pulumi.Input[_builtins.bool] allow_host_certificates: Specifies if certificates are allowed to be signed for use as a 'host'.
|
|
1006
|
+
:param pulumi.Input[_builtins.bool] allow_subdomains: Specifies if host certificates that are requested are allowed to be subdomains of those listed in `allowed_domains`.
|
|
1007
|
+
:param pulumi.Input[_builtins.bool] allow_user_certificates: Specifies if certificates are allowed to be signed for use as a 'user'.
|
|
1008
|
+
:param pulumi.Input[_builtins.bool] allow_user_key_ids: Specifies if users can override the key ID for a signed certificate with the `key_id` field.
|
|
1009
|
+
:param pulumi.Input[_builtins.str] allowed_critical_options: Specifies a comma-separated list of critical options that certificates can have when signed.
|
|
1010
|
+
:param pulumi.Input[_builtins.str] allowed_domains: The list of domains for which a client can request a host certificate.
|
|
1011
|
+
:param pulumi.Input[_builtins.bool] allowed_domains_template: Specifies if `allowed_domains` can be declared using
|
|
1013
1012
|
identity template policies. Non-templated domains are also permitted.
|
|
1014
|
-
:param pulumi.Input[
|
|
1013
|
+
:param pulumi.Input[_builtins.str] allowed_extensions: Specifies a comma-separated list of extensions that certificates can have when signed.
|
|
1015
1014
|
:param pulumi.Input[Sequence[pulumi.Input[Union['SecretBackendRoleAllowedUserKeyConfigArgs', 'SecretBackendRoleAllowedUserKeyConfigArgsDict']]]] allowed_user_key_configs: Set of configuration blocks to define allowed
|
|
1016
1015
|
user key configuration, like key type and their lengths. Can be specified multiple times.
|
|
1017
1016
|
*See Configuration-Options for more info*
|
|
1018
|
-
:param pulumi.Input[
|
|
1019
|
-
:param pulumi.Input[
|
|
1020
|
-
:param pulumi.Input[
|
|
1021
|
-
:param pulumi.Input[
|
|
1022
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[
|
|
1023
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[
|
|
1024
|
-
:param pulumi.Input[
|
|
1025
|
-
:param pulumi.Input[
|
|
1026
|
-
:param pulumi.Input[
|
|
1027
|
-
:param pulumi.Input[
|
|
1028
|
-
:param pulumi.Input[
|
|
1029
|
-
:param pulumi.Input[
|
|
1030
|
-
:param pulumi.Input[
|
|
1017
|
+
:param pulumi.Input[_builtins.str] allowed_users: Specifies a comma-separated list of usernames that are to be allowed, only if certain usernames are to be allowed.
|
|
1018
|
+
:param pulumi.Input[_builtins.bool] allowed_users_template: Specifies if `allowed_users` can be declared using identity template policies. Non-templated users are also permitted.
|
|
1019
|
+
:param pulumi.Input[_builtins.str] backend: The path where the SSH secret backend is mounted.
|
|
1020
|
+
:param pulumi.Input[_builtins.str] cidr_list: The comma-separated string of CIDR blocks for which this role is applicable.
|
|
1021
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] default_critical_options: Specifies a map of critical options that certificates have when signed.
|
|
1022
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] default_extensions: Specifies a map of extensions that certificates have when signed.
|
|
1023
|
+
:param pulumi.Input[_builtins.str] default_user: Specifies the default username for which a credential will be generated.
|
|
1024
|
+
:param pulumi.Input[_builtins.bool] default_user_template: If set, `default_users` can be specified using identity template values. A non-templated user is also permitted.
|
|
1025
|
+
:param pulumi.Input[_builtins.str] key_id_format: Specifies a custom format for the key id of a signed certificate.
|
|
1026
|
+
:param pulumi.Input[_builtins.str] key_type: Specifies the type of credentials generated by this role. This can be either `otp`, `dynamic` or `ca`.
|
|
1027
|
+
:param pulumi.Input[_builtins.str] max_ttl: Specifies the maximum Time To Live value.
|
|
1028
|
+
:param pulumi.Input[_builtins.str] name: Specifies the name of the role to create.
|
|
1029
|
+
:param pulumi.Input[_builtins.str] namespace: The namespace to provision the resource in.
|
|
1031
1030
|
The value should not contain leading or trailing forward slashes.
|
|
1032
1031
|
The `namespace` is always relative to the provider's configured [namespace](https://www.terraform.io/docs/providers/vault/index.html#namespace).
|
|
1033
1032
|
*Available only for Vault Enterprise*.
|
|
1034
|
-
:param pulumi.Input[
|
|
1035
|
-
:param pulumi.Input[
|
|
1033
|
+
:param pulumi.Input[_builtins.str] not_before_duration: Specifies the duration by which to backdate the ValidAfter property. Uses duration format strings.
|
|
1034
|
+
:param pulumi.Input[_builtins.str] ttl: Specifies the Time To Live value.
|
|
1036
1035
|
"""
|
|
1037
1036
|
...
|
|
1038
1037
|
@overload
|
|
@@ -1088,33 +1087,33 @@ class SecretBackendRole(pulumi.CustomResource):
|
|
|
1088
1087
|
def _internal_init(__self__,
|
|
1089
1088
|
resource_name: str,
|
|
1090
1089
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
1091
|
-
algorithm_signer: Optional[pulumi.Input[
|
|
1092
|
-
allow_bare_domains: Optional[pulumi.Input[
|
|
1093
|
-
allow_empty_principals: Optional[pulumi.Input[
|
|
1094
|
-
allow_host_certificates: Optional[pulumi.Input[
|
|
1095
|
-
allow_subdomains: Optional[pulumi.Input[
|
|
1096
|
-
allow_user_certificates: Optional[pulumi.Input[
|
|
1097
|
-
allow_user_key_ids: Optional[pulumi.Input[
|
|
1098
|
-
allowed_critical_options: Optional[pulumi.Input[
|
|
1099
|
-
allowed_domains: Optional[pulumi.Input[
|
|
1100
|
-
allowed_domains_template: Optional[pulumi.Input[
|
|
1101
|
-
allowed_extensions: Optional[pulumi.Input[
|
|
1090
|
+
algorithm_signer: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1091
|
+
allow_bare_domains: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1092
|
+
allow_empty_principals: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1093
|
+
allow_host_certificates: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1094
|
+
allow_subdomains: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1095
|
+
allow_user_certificates: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1096
|
+
allow_user_key_ids: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1097
|
+
allowed_critical_options: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1098
|
+
allowed_domains: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1099
|
+
allowed_domains_template: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1100
|
+
allowed_extensions: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1102
1101
|
allowed_user_key_configs: Optional[pulumi.Input[Sequence[pulumi.Input[Union['SecretBackendRoleAllowedUserKeyConfigArgs', 'SecretBackendRoleAllowedUserKeyConfigArgsDict']]]]] = None,
|
|
1103
|
-
allowed_users: Optional[pulumi.Input[
|
|
1104
|
-
allowed_users_template: Optional[pulumi.Input[
|
|
1105
|
-
backend: Optional[pulumi.Input[
|
|
1106
|
-
cidr_list: Optional[pulumi.Input[
|
|
1107
|
-
default_critical_options: Optional[pulumi.Input[Mapping[str, pulumi.Input[
|
|
1108
|
-
default_extensions: Optional[pulumi.Input[Mapping[str, pulumi.Input[
|
|
1109
|
-
default_user: Optional[pulumi.Input[
|
|
1110
|
-
default_user_template: Optional[pulumi.Input[
|
|
1111
|
-
key_id_format: Optional[pulumi.Input[
|
|
1112
|
-
key_type: Optional[pulumi.Input[
|
|
1113
|
-
max_ttl: Optional[pulumi.Input[
|
|
1114
|
-
name: Optional[pulumi.Input[
|
|
1115
|
-
namespace: Optional[pulumi.Input[
|
|
1116
|
-
not_before_duration: Optional[pulumi.Input[
|
|
1117
|
-
ttl: Optional[pulumi.Input[
|
|
1102
|
+
allowed_users: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1103
|
+
allowed_users_template: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1104
|
+
backend: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1105
|
+
cidr_list: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1106
|
+
default_critical_options: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
|
|
1107
|
+
default_extensions: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
|
|
1108
|
+
default_user: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1109
|
+
default_user_template: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1110
|
+
key_id_format: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1111
|
+
key_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1112
|
+
max_ttl: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1113
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1114
|
+
namespace: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1115
|
+
not_before_duration: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1116
|
+
ttl: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1118
1117
|
__props__=None):
|
|
1119
1118
|
opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
|
|
1120
1119
|
if not isinstance(opts, pulumi.ResourceOptions):
|
|
@@ -1165,33 +1164,33 @@ class SecretBackendRole(pulumi.CustomResource):
|
|
|
1165
1164
|
def get(resource_name: str,
|
|
1166
1165
|
id: pulumi.Input[str],
|
|
1167
1166
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
1168
|
-
algorithm_signer: Optional[pulumi.Input[
|
|
1169
|
-
allow_bare_domains: Optional[pulumi.Input[
|
|
1170
|
-
allow_empty_principals: Optional[pulumi.Input[
|
|
1171
|
-
allow_host_certificates: Optional[pulumi.Input[
|
|
1172
|
-
allow_subdomains: Optional[pulumi.Input[
|
|
1173
|
-
allow_user_certificates: Optional[pulumi.Input[
|
|
1174
|
-
allow_user_key_ids: Optional[pulumi.Input[
|
|
1175
|
-
allowed_critical_options: Optional[pulumi.Input[
|
|
1176
|
-
allowed_domains: Optional[pulumi.Input[
|
|
1177
|
-
allowed_domains_template: Optional[pulumi.Input[
|
|
1178
|
-
allowed_extensions: Optional[pulumi.Input[
|
|
1167
|
+
algorithm_signer: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1168
|
+
allow_bare_domains: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1169
|
+
allow_empty_principals: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1170
|
+
allow_host_certificates: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1171
|
+
allow_subdomains: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1172
|
+
allow_user_certificates: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1173
|
+
allow_user_key_ids: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1174
|
+
allowed_critical_options: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1175
|
+
allowed_domains: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1176
|
+
allowed_domains_template: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1177
|
+
allowed_extensions: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1179
1178
|
allowed_user_key_configs: Optional[pulumi.Input[Sequence[pulumi.Input[Union['SecretBackendRoleAllowedUserKeyConfigArgs', 'SecretBackendRoleAllowedUserKeyConfigArgsDict']]]]] = None,
|
|
1180
|
-
allowed_users: Optional[pulumi.Input[
|
|
1181
|
-
allowed_users_template: Optional[pulumi.Input[
|
|
1182
|
-
backend: Optional[pulumi.Input[
|
|
1183
|
-
cidr_list: Optional[pulumi.Input[
|
|
1184
|
-
default_critical_options: Optional[pulumi.Input[Mapping[str, pulumi.Input[
|
|
1185
|
-
default_extensions: Optional[pulumi.Input[Mapping[str, pulumi.Input[
|
|
1186
|
-
default_user: Optional[pulumi.Input[
|
|
1187
|
-
default_user_template: Optional[pulumi.Input[
|
|
1188
|
-
key_id_format: Optional[pulumi.Input[
|
|
1189
|
-
key_type: Optional[pulumi.Input[
|
|
1190
|
-
max_ttl: Optional[pulumi.Input[
|
|
1191
|
-
name: Optional[pulumi.Input[
|
|
1192
|
-
namespace: Optional[pulumi.Input[
|
|
1193
|
-
not_before_duration: Optional[pulumi.Input[
|
|
1194
|
-
ttl: Optional[pulumi.Input[
|
|
1179
|
+
allowed_users: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1180
|
+
allowed_users_template: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1181
|
+
backend: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1182
|
+
cidr_list: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1183
|
+
default_critical_options: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
|
|
1184
|
+
default_extensions: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
|
|
1185
|
+
default_user: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1186
|
+
default_user_template: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1187
|
+
key_id_format: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1188
|
+
key_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1189
|
+
max_ttl: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1190
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1191
|
+
namespace: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1192
|
+
not_before_duration: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1193
|
+
ttl: Optional[pulumi.Input[_builtins.str]] = None) -> 'SecretBackendRole':
|
|
1195
1194
|
"""
|
|
1196
1195
|
Get an existing SecretBackendRole resource's state with the given name, id, and optional extra
|
|
1197
1196
|
properties used to qualify the lookup.
|
|
@@ -1199,41 +1198,41 @@ class SecretBackendRole(pulumi.CustomResource):
|
|
|
1199
1198
|
:param str resource_name: The unique name of the resulting resource.
|
|
1200
1199
|
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
|
|
1201
1200
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
1202
|
-
:param pulumi.Input[
|
|
1203
|
-
:param pulumi.Input[
|
|
1204
|
-
:param pulumi.Input[
|
|
1201
|
+
:param pulumi.Input[_builtins.str] algorithm_signer: When supplied, this value specifies a signing algorithm for the key. Possible values: ssh-rsa, rsa-sha2-256, rsa-sha2-512.
|
|
1202
|
+
:param pulumi.Input[_builtins.bool] allow_bare_domains: Specifies if host certificates that are requested are allowed to use the base domains listed in `allowed_domains`.
|
|
1203
|
+
:param pulumi.Input[_builtins.bool] allow_empty_principals: Allow signing certificates with no
|
|
1205
1204
|
valid principals (e.g. any valid principal). For backwards compatibility
|
|
1206
1205
|
only. The default of false is highly recommended.
|
|
1207
|
-
:param pulumi.Input[
|
|
1208
|
-
:param pulumi.Input[
|
|
1209
|
-
:param pulumi.Input[
|
|
1210
|
-
:param pulumi.Input[
|
|
1211
|
-
:param pulumi.Input[
|
|
1212
|
-
:param pulumi.Input[
|
|
1213
|
-
:param pulumi.Input[
|
|
1206
|
+
:param pulumi.Input[_builtins.bool] allow_host_certificates: Specifies if certificates are allowed to be signed for use as a 'host'.
|
|
1207
|
+
:param pulumi.Input[_builtins.bool] allow_subdomains: Specifies if host certificates that are requested are allowed to be subdomains of those listed in `allowed_domains`.
|
|
1208
|
+
:param pulumi.Input[_builtins.bool] allow_user_certificates: Specifies if certificates are allowed to be signed for use as a 'user'.
|
|
1209
|
+
:param pulumi.Input[_builtins.bool] allow_user_key_ids: Specifies if users can override the key ID for a signed certificate with the `key_id` field.
|
|
1210
|
+
:param pulumi.Input[_builtins.str] allowed_critical_options: Specifies a comma-separated list of critical options that certificates can have when signed.
|
|
1211
|
+
:param pulumi.Input[_builtins.str] allowed_domains: The list of domains for which a client can request a host certificate.
|
|
1212
|
+
:param pulumi.Input[_builtins.bool] allowed_domains_template: Specifies if `allowed_domains` can be declared using
|
|
1214
1213
|
identity template policies. Non-templated domains are also permitted.
|
|
1215
|
-
:param pulumi.Input[
|
|
1214
|
+
:param pulumi.Input[_builtins.str] allowed_extensions: Specifies a comma-separated list of extensions that certificates can have when signed.
|
|
1216
1215
|
:param pulumi.Input[Sequence[pulumi.Input[Union['SecretBackendRoleAllowedUserKeyConfigArgs', 'SecretBackendRoleAllowedUserKeyConfigArgsDict']]]] allowed_user_key_configs: Set of configuration blocks to define allowed
|
|
1217
1216
|
user key configuration, like key type and their lengths. Can be specified multiple times.
|
|
1218
1217
|
*See Configuration-Options for more info*
|
|
1219
|
-
:param pulumi.Input[
|
|
1220
|
-
:param pulumi.Input[
|
|
1221
|
-
:param pulumi.Input[
|
|
1222
|
-
:param pulumi.Input[
|
|
1223
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[
|
|
1224
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[
|
|
1225
|
-
:param pulumi.Input[
|
|
1226
|
-
:param pulumi.Input[
|
|
1227
|
-
:param pulumi.Input[
|
|
1228
|
-
:param pulumi.Input[
|
|
1229
|
-
:param pulumi.Input[
|
|
1230
|
-
:param pulumi.Input[
|
|
1231
|
-
:param pulumi.Input[
|
|
1218
|
+
:param pulumi.Input[_builtins.str] allowed_users: Specifies a comma-separated list of usernames that are to be allowed, only if certain usernames are to be allowed.
|
|
1219
|
+
:param pulumi.Input[_builtins.bool] allowed_users_template: Specifies if `allowed_users` can be declared using identity template policies. Non-templated users are also permitted.
|
|
1220
|
+
:param pulumi.Input[_builtins.str] backend: The path where the SSH secret backend is mounted.
|
|
1221
|
+
:param pulumi.Input[_builtins.str] cidr_list: The comma-separated string of CIDR blocks for which this role is applicable.
|
|
1222
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] default_critical_options: Specifies a map of critical options that certificates have when signed.
|
|
1223
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] default_extensions: Specifies a map of extensions that certificates have when signed.
|
|
1224
|
+
:param pulumi.Input[_builtins.str] default_user: Specifies the default username for which a credential will be generated.
|
|
1225
|
+
:param pulumi.Input[_builtins.bool] default_user_template: If set, `default_users` can be specified using identity template values. A non-templated user is also permitted.
|
|
1226
|
+
:param pulumi.Input[_builtins.str] key_id_format: Specifies a custom format for the key id of a signed certificate.
|
|
1227
|
+
:param pulumi.Input[_builtins.str] key_type: Specifies the type of credentials generated by this role. This can be either `otp`, `dynamic` or `ca`.
|
|
1228
|
+
:param pulumi.Input[_builtins.str] max_ttl: Specifies the maximum Time To Live value.
|
|
1229
|
+
:param pulumi.Input[_builtins.str] name: Specifies the name of the role to create.
|
|
1230
|
+
:param pulumi.Input[_builtins.str] namespace: The namespace to provision the resource in.
|
|
1232
1231
|
The value should not contain leading or trailing forward slashes.
|
|
1233
1232
|
The `namespace` is always relative to the provider's configured [namespace](https://www.terraform.io/docs/providers/vault/index.html#namespace).
|
|
1234
1233
|
*Available only for Vault Enterprise*.
|
|
1235
|
-
:param pulumi.Input[
|
|
1236
|
-
:param pulumi.Input[
|
|
1234
|
+
:param pulumi.Input[_builtins.str] not_before_duration: Specifies the duration by which to backdate the ValidAfter property. Uses duration format strings.
|
|
1235
|
+
:param pulumi.Input[_builtins.str] ttl: Specifies the Time To Live value.
|
|
1237
1236
|
"""
|
|
1238
1237
|
opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
|
|
1239
1238
|
|
|
@@ -1268,25 +1267,25 @@ class SecretBackendRole(pulumi.CustomResource):
|
|
|
1268
1267
|
__props__.__dict__["ttl"] = ttl
|
|
1269
1268
|
return SecretBackendRole(resource_name, opts=opts, __props__=__props__)
|
|
1270
1269
|
|
|
1271
|
-
@property
|
|
1270
|
+
@_builtins.property
|
|
1272
1271
|
@pulumi.getter(name="algorithmSigner")
|
|
1273
|
-
def algorithm_signer(self) -> pulumi.Output[
|
|
1272
|
+
def algorithm_signer(self) -> pulumi.Output[_builtins.str]:
|
|
1274
1273
|
"""
|
|
1275
1274
|
When supplied, this value specifies a signing algorithm for the key. Possible values: ssh-rsa, rsa-sha2-256, rsa-sha2-512.
|
|
1276
1275
|
"""
|
|
1277
1276
|
return pulumi.get(self, "algorithm_signer")
|
|
1278
1277
|
|
|
1279
|
-
@property
|
|
1278
|
+
@_builtins.property
|
|
1280
1279
|
@pulumi.getter(name="allowBareDomains")
|
|
1281
|
-
def allow_bare_domains(self) -> pulumi.Output[Optional[
|
|
1280
|
+
def allow_bare_domains(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1282
1281
|
"""
|
|
1283
1282
|
Specifies if host certificates that are requested are allowed to use the base domains listed in `allowed_domains`.
|
|
1284
1283
|
"""
|
|
1285
1284
|
return pulumi.get(self, "allow_bare_domains")
|
|
1286
1285
|
|
|
1287
|
-
@property
|
|
1286
|
+
@_builtins.property
|
|
1288
1287
|
@pulumi.getter(name="allowEmptyPrincipals")
|
|
1289
|
-
def allow_empty_principals(self) -> pulumi.Output[Optional[
|
|
1288
|
+
def allow_empty_principals(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1290
1289
|
"""
|
|
1291
1290
|
Allow signing certificates with no
|
|
1292
1291
|
valid principals (e.g. any valid principal). For backwards compatibility
|
|
@@ -1294,72 +1293,72 @@ class SecretBackendRole(pulumi.CustomResource):
|
|
|
1294
1293
|
"""
|
|
1295
1294
|
return pulumi.get(self, "allow_empty_principals")
|
|
1296
1295
|
|
|
1297
|
-
@property
|
|
1296
|
+
@_builtins.property
|
|
1298
1297
|
@pulumi.getter(name="allowHostCertificates")
|
|
1299
|
-
def allow_host_certificates(self) -> pulumi.Output[Optional[
|
|
1298
|
+
def allow_host_certificates(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1300
1299
|
"""
|
|
1301
1300
|
Specifies if certificates are allowed to be signed for use as a 'host'.
|
|
1302
1301
|
"""
|
|
1303
1302
|
return pulumi.get(self, "allow_host_certificates")
|
|
1304
1303
|
|
|
1305
|
-
@property
|
|
1304
|
+
@_builtins.property
|
|
1306
1305
|
@pulumi.getter(name="allowSubdomains")
|
|
1307
|
-
def allow_subdomains(self) -> pulumi.Output[Optional[
|
|
1306
|
+
def allow_subdomains(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1308
1307
|
"""
|
|
1309
1308
|
Specifies if host certificates that are requested are allowed to be subdomains of those listed in `allowed_domains`.
|
|
1310
1309
|
"""
|
|
1311
1310
|
return pulumi.get(self, "allow_subdomains")
|
|
1312
1311
|
|
|
1313
|
-
@property
|
|
1312
|
+
@_builtins.property
|
|
1314
1313
|
@pulumi.getter(name="allowUserCertificates")
|
|
1315
|
-
def allow_user_certificates(self) -> pulumi.Output[Optional[
|
|
1314
|
+
def allow_user_certificates(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1316
1315
|
"""
|
|
1317
1316
|
Specifies if certificates are allowed to be signed for use as a 'user'.
|
|
1318
1317
|
"""
|
|
1319
1318
|
return pulumi.get(self, "allow_user_certificates")
|
|
1320
1319
|
|
|
1321
|
-
@property
|
|
1320
|
+
@_builtins.property
|
|
1322
1321
|
@pulumi.getter(name="allowUserKeyIds")
|
|
1323
|
-
def allow_user_key_ids(self) -> pulumi.Output[Optional[
|
|
1322
|
+
def allow_user_key_ids(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1324
1323
|
"""
|
|
1325
1324
|
Specifies if users can override the key ID for a signed certificate with the `key_id` field.
|
|
1326
1325
|
"""
|
|
1327
1326
|
return pulumi.get(self, "allow_user_key_ids")
|
|
1328
1327
|
|
|
1329
|
-
@property
|
|
1328
|
+
@_builtins.property
|
|
1330
1329
|
@pulumi.getter(name="allowedCriticalOptions")
|
|
1331
|
-
def allowed_critical_options(self) -> pulumi.Output[Optional[
|
|
1330
|
+
def allowed_critical_options(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1332
1331
|
"""
|
|
1333
1332
|
Specifies a comma-separated list of critical options that certificates can have when signed.
|
|
1334
1333
|
"""
|
|
1335
1334
|
return pulumi.get(self, "allowed_critical_options")
|
|
1336
1335
|
|
|
1337
|
-
@property
|
|
1336
|
+
@_builtins.property
|
|
1338
1337
|
@pulumi.getter(name="allowedDomains")
|
|
1339
|
-
def allowed_domains(self) -> pulumi.Output[Optional[
|
|
1338
|
+
def allowed_domains(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1340
1339
|
"""
|
|
1341
1340
|
The list of domains for which a client can request a host certificate.
|
|
1342
1341
|
"""
|
|
1343
1342
|
return pulumi.get(self, "allowed_domains")
|
|
1344
1343
|
|
|
1345
|
-
@property
|
|
1344
|
+
@_builtins.property
|
|
1346
1345
|
@pulumi.getter(name="allowedDomainsTemplate")
|
|
1347
|
-
def allowed_domains_template(self) -> pulumi.Output[
|
|
1346
|
+
def allowed_domains_template(self) -> pulumi.Output[_builtins.bool]:
|
|
1348
1347
|
"""
|
|
1349
1348
|
Specifies if `allowed_domains` can be declared using
|
|
1350
1349
|
identity template policies. Non-templated domains are also permitted.
|
|
1351
1350
|
"""
|
|
1352
1351
|
return pulumi.get(self, "allowed_domains_template")
|
|
1353
1352
|
|
|
1354
|
-
@property
|
|
1353
|
+
@_builtins.property
|
|
1355
1354
|
@pulumi.getter(name="allowedExtensions")
|
|
1356
|
-
def allowed_extensions(self) -> pulumi.Output[Optional[
|
|
1355
|
+
def allowed_extensions(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1357
1356
|
"""
|
|
1358
1357
|
Specifies a comma-separated list of extensions that certificates can have when signed.
|
|
1359
1358
|
"""
|
|
1360
1359
|
return pulumi.get(self, "allowed_extensions")
|
|
1361
1360
|
|
|
1362
|
-
@property
|
|
1361
|
+
@_builtins.property
|
|
1363
1362
|
@pulumi.getter(name="allowedUserKeyConfigs")
|
|
1364
1363
|
def allowed_user_key_configs(self) -> pulumi.Output[Optional[Sequence['outputs.SecretBackendRoleAllowedUserKeyConfig']]]:
|
|
1365
1364
|
"""
|
|
@@ -1369,105 +1368,105 @@ class SecretBackendRole(pulumi.CustomResource):
|
|
|
1369
1368
|
"""
|
|
1370
1369
|
return pulumi.get(self, "allowed_user_key_configs")
|
|
1371
1370
|
|
|
1372
|
-
@property
|
|
1371
|
+
@_builtins.property
|
|
1373
1372
|
@pulumi.getter(name="allowedUsers")
|
|
1374
|
-
def allowed_users(self) -> pulumi.Output[Optional[
|
|
1373
|
+
def allowed_users(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1375
1374
|
"""
|
|
1376
1375
|
Specifies a comma-separated list of usernames that are to be allowed, only if certain usernames are to be allowed.
|
|
1377
1376
|
"""
|
|
1378
1377
|
return pulumi.get(self, "allowed_users")
|
|
1379
1378
|
|
|
1380
|
-
@property
|
|
1379
|
+
@_builtins.property
|
|
1381
1380
|
@pulumi.getter(name="allowedUsersTemplate")
|
|
1382
|
-
def allowed_users_template(self) -> pulumi.Output[Optional[
|
|
1381
|
+
def allowed_users_template(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1383
1382
|
"""
|
|
1384
1383
|
Specifies if `allowed_users` can be declared using identity template policies. Non-templated users are also permitted.
|
|
1385
1384
|
"""
|
|
1386
1385
|
return pulumi.get(self, "allowed_users_template")
|
|
1387
1386
|
|
|
1388
|
-
@property
|
|
1387
|
+
@_builtins.property
|
|
1389
1388
|
@pulumi.getter
|
|
1390
|
-
def backend(self) -> pulumi.Output[
|
|
1389
|
+
def backend(self) -> pulumi.Output[_builtins.str]:
|
|
1391
1390
|
"""
|
|
1392
1391
|
The path where the SSH secret backend is mounted.
|
|
1393
1392
|
"""
|
|
1394
1393
|
return pulumi.get(self, "backend")
|
|
1395
1394
|
|
|
1396
|
-
@property
|
|
1395
|
+
@_builtins.property
|
|
1397
1396
|
@pulumi.getter(name="cidrList")
|
|
1398
|
-
def cidr_list(self) -> pulumi.Output[Optional[
|
|
1397
|
+
def cidr_list(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1399
1398
|
"""
|
|
1400
1399
|
The comma-separated string of CIDR blocks for which this role is applicable.
|
|
1401
1400
|
"""
|
|
1402
1401
|
return pulumi.get(self, "cidr_list")
|
|
1403
1402
|
|
|
1404
|
-
@property
|
|
1403
|
+
@_builtins.property
|
|
1405
1404
|
@pulumi.getter(name="defaultCriticalOptions")
|
|
1406
|
-
def default_critical_options(self) -> pulumi.Output[Optional[Mapping[str,
|
|
1405
|
+
def default_critical_options(self) -> pulumi.Output[Optional[Mapping[str, _builtins.str]]]:
|
|
1407
1406
|
"""
|
|
1408
1407
|
Specifies a map of critical options that certificates have when signed.
|
|
1409
1408
|
"""
|
|
1410
1409
|
return pulumi.get(self, "default_critical_options")
|
|
1411
1410
|
|
|
1412
|
-
@property
|
|
1411
|
+
@_builtins.property
|
|
1413
1412
|
@pulumi.getter(name="defaultExtensions")
|
|
1414
|
-
def default_extensions(self) -> pulumi.Output[Optional[Mapping[str,
|
|
1413
|
+
def default_extensions(self) -> pulumi.Output[Optional[Mapping[str, _builtins.str]]]:
|
|
1415
1414
|
"""
|
|
1416
1415
|
Specifies a map of extensions that certificates have when signed.
|
|
1417
1416
|
"""
|
|
1418
1417
|
return pulumi.get(self, "default_extensions")
|
|
1419
1418
|
|
|
1420
|
-
@property
|
|
1419
|
+
@_builtins.property
|
|
1421
1420
|
@pulumi.getter(name="defaultUser")
|
|
1422
|
-
def default_user(self) -> pulumi.Output[Optional[
|
|
1421
|
+
def default_user(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1423
1422
|
"""
|
|
1424
1423
|
Specifies the default username for which a credential will be generated.
|
|
1425
1424
|
"""
|
|
1426
1425
|
return pulumi.get(self, "default_user")
|
|
1427
1426
|
|
|
1428
|
-
@property
|
|
1427
|
+
@_builtins.property
|
|
1429
1428
|
@pulumi.getter(name="defaultUserTemplate")
|
|
1430
|
-
def default_user_template(self) -> pulumi.Output[Optional[
|
|
1429
|
+
def default_user_template(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1431
1430
|
"""
|
|
1432
1431
|
If set, `default_users` can be specified using identity template values. A non-templated user is also permitted.
|
|
1433
1432
|
"""
|
|
1434
1433
|
return pulumi.get(self, "default_user_template")
|
|
1435
1434
|
|
|
1436
|
-
@property
|
|
1435
|
+
@_builtins.property
|
|
1437
1436
|
@pulumi.getter(name="keyIdFormat")
|
|
1438
|
-
def key_id_format(self) -> pulumi.Output[Optional[
|
|
1437
|
+
def key_id_format(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1439
1438
|
"""
|
|
1440
1439
|
Specifies a custom format for the key id of a signed certificate.
|
|
1441
1440
|
"""
|
|
1442
1441
|
return pulumi.get(self, "key_id_format")
|
|
1443
1442
|
|
|
1444
|
-
@property
|
|
1443
|
+
@_builtins.property
|
|
1445
1444
|
@pulumi.getter(name="keyType")
|
|
1446
|
-
def key_type(self) -> pulumi.Output[
|
|
1445
|
+
def key_type(self) -> pulumi.Output[_builtins.str]:
|
|
1447
1446
|
"""
|
|
1448
1447
|
Specifies the type of credentials generated by this role. This can be either `otp`, `dynamic` or `ca`.
|
|
1449
1448
|
"""
|
|
1450
1449
|
return pulumi.get(self, "key_type")
|
|
1451
1450
|
|
|
1452
|
-
@property
|
|
1451
|
+
@_builtins.property
|
|
1453
1452
|
@pulumi.getter(name="maxTtl")
|
|
1454
|
-
def max_ttl(self) -> pulumi.Output[
|
|
1453
|
+
def max_ttl(self) -> pulumi.Output[_builtins.str]:
|
|
1455
1454
|
"""
|
|
1456
1455
|
Specifies the maximum Time To Live value.
|
|
1457
1456
|
"""
|
|
1458
1457
|
return pulumi.get(self, "max_ttl")
|
|
1459
1458
|
|
|
1460
|
-
@property
|
|
1459
|
+
@_builtins.property
|
|
1461
1460
|
@pulumi.getter
|
|
1462
|
-
def name(self) -> pulumi.Output[
|
|
1461
|
+
def name(self) -> pulumi.Output[_builtins.str]:
|
|
1463
1462
|
"""
|
|
1464
1463
|
Specifies the name of the role to create.
|
|
1465
1464
|
"""
|
|
1466
1465
|
return pulumi.get(self, "name")
|
|
1467
1466
|
|
|
1468
|
-
@property
|
|
1467
|
+
@_builtins.property
|
|
1469
1468
|
@pulumi.getter
|
|
1470
|
-
def namespace(self) -> pulumi.Output[Optional[
|
|
1469
|
+
def namespace(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1471
1470
|
"""
|
|
1472
1471
|
The namespace to provision the resource in.
|
|
1473
1472
|
The value should not contain leading or trailing forward slashes.
|
|
@@ -1476,17 +1475,17 @@ class SecretBackendRole(pulumi.CustomResource):
|
|
|
1476
1475
|
"""
|
|
1477
1476
|
return pulumi.get(self, "namespace")
|
|
1478
1477
|
|
|
1479
|
-
@property
|
|
1478
|
+
@_builtins.property
|
|
1480
1479
|
@pulumi.getter(name="notBeforeDuration")
|
|
1481
|
-
def not_before_duration(self) -> pulumi.Output[
|
|
1480
|
+
def not_before_duration(self) -> pulumi.Output[_builtins.str]:
|
|
1482
1481
|
"""
|
|
1483
1482
|
Specifies the duration by which to backdate the ValidAfter property. Uses duration format strings.
|
|
1484
1483
|
"""
|
|
1485
1484
|
return pulumi.get(self, "not_before_duration")
|
|
1486
1485
|
|
|
1487
|
-
@property
|
|
1486
|
+
@_builtins.property
|
|
1488
1487
|
@pulumi.getter
|
|
1489
|
-
def ttl(self) -> pulumi.Output[
|
|
1488
|
+
def ttl(self) -> pulumi.Output[_builtins.str]:
|
|
1490
1489
|
"""
|
|
1491
1490
|
Specifies the Time To Live value.
|
|
1492
1491
|
"""
|