pulumi-vault 7.2.0a1752907825__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.0a1752907825.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.0a1752907825.dist-info/RECORD +0 -268
- {pulumi_vault-7.2.0a1752907825.dist-info → pulumi_vault-7.2.0a1753398491.dist-info}/WHEEL +0 -0
- {pulumi_vault-7.2.0a1752907825.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
|
|
@@ -20,74 +19,74 @@ __all__ = ['SecretBackendIntermediateCertRequestArgs', 'SecretBackendIntermediat
|
|
|
20
19
|
@pulumi.input_type
|
|
21
20
|
class SecretBackendIntermediateCertRequestArgs:
|
|
22
21
|
def __init__(__self__, *,
|
|
23
|
-
backend: pulumi.Input[
|
|
24
|
-
common_name: pulumi.Input[
|
|
25
|
-
type: pulumi.Input[
|
|
26
|
-
add_basic_constraints: Optional[pulumi.Input[
|
|
27
|
-
alt_names: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
28
|
-
country: Optional[pulumi.Input[
|
|
29
|
-
exclude_cn_from_sans: Optional[pulumi.Input[
|
|
30
|
-
format: Optional[pulumi.Input[
|
|
31
|
-
ip_sans: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
32
|
-
key_bits: Optional[pulumi.Input[
|
|
33
|
-
key_name: Optional[pulumi.Input[
|
|
34
|
-
key_ref: Optional[pulumi.Input[
|
|
35
|
-
key_type: Optional[pulumi.Input[
|
|
36
|
-
key_usages: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
37
|
-
locality: Optional[pulumi.Input[
|
|
38
|
-
managed_key_id: Optional[pulumi.Input[
|
|
39
|
-
managed_key_name: Optional[pulumi.Input[
|
|
40
|
-
namespace: Optional[pulumi.Input[
|
|
41
|
-
organization: Optional[pulumi.Input[
|
|
42
|
-
other_sans: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
43
|
-
ou: Optional[pulumi.Input[
|
|
44
|
-
postal_code: Optional[pulumi.Input[
|
|
45
|
-
private_key_format: Optional[pulumi.Input[
|
|
46
|
-
province: Optional[pulumi.Input[
|
|
47
|
-
serial_number: Optional[pulumi.Input[
|
|
48
|
-
signature_bits: Optional[pulumi.Input[
|
|
49
|
-
street_address: Optional[pulumi.Input[
|
|
50
|
-
uri_sans: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
22
|
+
backend: pulumi.Input[_builtins.str],
|
|
23
|
+
common_name: pulumi.Input[_builtins.str],
|
|
24
|
+
type: pulumi.Input[_builtins.str],
|
|
25
|
+
add_basic_constraints: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
26
|
+
alt_names: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
27
|
+
country: Optional[pulumi.Input[_builtins.str]] = None,
|
|
28
|
+
exclude_cn_from_sans: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
29
|
+
format: Optional[pulumi.Input[_builtins.str]] = None,
|
|
30
|
+
ip_sans: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
31
|
+
key_bits: Optional[pulumi.Input[_builtins.int]] = None,
|
|
32
|
+
key_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
33
|
+
key_ref: Optional[pulumi.Input[_builtins.str]] = None,
|
|
34
|
+
key_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
35
|
+
key_usages: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
36
|
+
locality: Optional[pulumi.Input[_builtins.str]] = None,
|
|
37
|
+
managed_key_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
38
|
+
managed_key_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
39
|
+
namespace: Optional[pulumi.Input[_builtins.str]] = None,
|
|
40
|
+
organization: Optional[pulumi.Input[_builtins.str]] = None,
|
|
41
|
+
other_sans: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
42
|
+
ou: Optional[pulumi.Input[_builtins.str]] = None,
|
|
43
|
+
postal_code: Optional[pulumi.Input[_builtins.str]] = None,
|
|
44
|
+
private_key_format: Optional[pulumi.Input[_builtins.str]] = None,
|
|
45
|
+
province: Optional[pulumi.Input[_builtins.str]] = None,
|
|
46
|
+
serial_number: Optional[pulumi.Input[_builtins.str]] = None,
|
|
47
|
+
signature_bits: Optional[pulumi.Input[_builtins.int]] = None,
|
|
48
|
+
street_address: Optional[pulumi.Input[_builtins.str]] = None,
|
|
49
|
+
uri_sans: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
|
|
51
50
|
"""
|
|
52
51
|
The set of arguments for constructing a SecretBackendIntermediateCertRequest resource.
|
|
53
|
-
:param pulumi.Input[
|
|
54
|
-
:param pulumi.Input[
|
|
55
|
-
:param pulumi.Input[
|
|
52
|
+
:param pulumi.Input[_builtins.str] backend: The PKI secret backend the resource belongs to.
|
|
53
|
+
:param pulumi.Input[_builtins.str] common_name: CN of intermediate to create
|
|
54
|
+
:param pulumi.Input[_builtins.str] type: Type of intermediate to create. Must be either \\"exported\\" or \\"internal\\"
|
|
56
55
|
or \\"kms\\"
|
|
57
|
-
:param pulumi.Input[
|
|
56
|
+
:param pulumi.Input[_builtins.bool] add_basic_constraints: Adds a Basic Constraints extension with 'CA: true'.
|
|
58
57
|
Only needed as a workaround in some compatibility scenarios with Active Directory
|
|
59
58
|
Certificate Services
|
|
60
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
61
|
-
:param pulumi.Input[
|
|
62
|
-
:param pulumi.Input[
|
|
63
|
-
:param pulumi.Input[
|
|
64
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
65
|
-
:param pulumi.Input[
|
|
66
|
-
:param pulumi.Input[
|
|
59
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] alt_names: List of alternative names
|
|
60
|
+
:param pulumi.Input[_builtins.str] country: The country
|
|
61
|
+
:param pulumi.Input[_builtins.bool] exclude_cn_from_sans: Flag to exclude CN from SANs
|
|
62
|
+
:param pulumi.Input[_builtins.str] format: The format of data
|
|
63
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] ip_sans: List of alternative IPs
|
|
64
|
+
:param pulumi.Input[_builtins.int] key_bits: The number of bits to use
|
|
65
|
+
:param pulumi.Input[_builtins.str] key_name: When a new key is created with this request, optionally specifies
|
|
67
66
|
the name for this. The global ref `default` may not be used as a name.
|
|
68
|
-
:param pulumi.Input[
|
|
67
|
+
:param pulumi.Input[_builtins.str] key_ref: Specifies the key (either default, by name, or by identifier) to use
|
|
69
68
|
for generating this request. Only suitable for `type=existing` requests.
|
|
70
|
-
:param pulumi.Input[
|
|
71
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
72
|
-
:param pulumi.Input[
|
|
73
|
-
:param pulumi.Input[
|
|
69
|
+
:param pulumi.Input[_builtins.str] key_type: The desired key type
|
|
70
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] key_usages: Specifies key_usage to encode in the generated certificate.
|
|
71
|
+
:param pulumi.Input[_builtins.str] locality: The locality
|
|
72
|
+
:param pulumi.Input[_builtins.str] managed_key_id: The ID of the previously configured managed key. This field is
|
|
74
73
|
required if `type` is `kms` and it conflicts with `managed_key_name`
|
|
75
|
-
:param pulumi.Input[
|
|
74
|
+
:param pulumi.Input[_builtins.str] managed_key_name: The name of the previously configured managed key. This field is
|
|
76
75
|
required if `type` is `kms` and it conflicts with `managed_key_id`
|
|
77
|
-
:param pulumi.Input[
|
|
76
|
+
:param pulumi.Input[_builtins.str] namespace: The namespace to provision the resource in.
|
|
78
77
|
The value should not contain leading or trailing forward slashes.
|
|
79
78
|
The `namespace` is always relative to the provider's configured [namespace](https://www.terraform.io/docs/providers/vault/index.html#namespace).
|
|
80
79
|
*Available only for Vault Enterprise*.
|
|
81
|
-
:param pulumi.Input[
|
|
82
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
83
|
-
:param pulumi.Input[
|
|
84
|
-
:param pulumi.Input[
|
|
85
|
-
:param pulumi.Input[
|
|
86
|
-
:param pulumi.Input[
|
|
87
|
-
:param pulumi.Input[
|
|
88
|
-
:param pulumi.Input[
|
|
89
|
-
:param pulumi.Input[
|
|
90
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
80
|
+
:param pulumi.Input[_builtins.str] organization: The organization
|
|
81
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] other_sans: List of other SANs
|
|
82
|
+
:param pulumi.Input[_builtins.str] ou: The organization unit
|
|
83
|
+
:param pulumi.Input[_builtins.str] postal_code: The postal code
|
|
84
|
+
:param pulumi.Input[_builtins.str] private_key_format: The private key format
|
|
85
|
+
:param pulumi.Input[_builtins.str] province: The province
|
|
86
|
+
:param pulumi.Input[_builtins.str] serial_number: The requested Subject's named Serial Number
|
|
87
|
+
:param pulumi.Input[_builtins.int] signature_bits: The number of bits to use in the signature algorithm
|
|
88
|
+
:param pulumi.Input[_builtins.str] street_address: The street address
|
|
89
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] uri_sans: List of alternative URIs
|
|
91
90
|
"""
|
|
92
91
|
pulumi.set(__self__, "backend", backend)
|
|
93
92
|
pulumi.set(__self__, "common_name", common_name)
|
|
@@ -143,33 +142,33 @@ class SecretBackendIntermediateCertRequestArgs:
|
|
|
143
142
|
if uri_sans is not None:
|
|
144
143
|
pulumi.set(__self__, "uri_sans", uri_sans)
|
|
145
144
|
|
|
146
|
-
@property
|
|
145
|
+
@_builtins.property
|
|
147
146
|
@pulumi.getter
|
|
148
|
-
def backend(self) -> pulumi.Input[
|
|
147
|
+
def backend(self) -> pulumi.Input[_builtins.str]:
|
|
149
148
|
"""
|
|
150
149
|
The PKI secret backend the resource belongs to.
|
|
151
150
|
"""
|
|
152
151
|
return pulumi.get(self, "backend")
|
|
153
152
|
|
|
154
153
|
@backend.setter
|
|
155
|
-
def backend(self, value: pulumi.Input[
|
|
154
|
+
def backend(self, value: pulumi.Input[_builtins.str]):
|
|
156
155
|
pulumi.set(self, "backend", value)
|
|
157
156
|
|
|
158
|
-
@property
|
|
157
|
+
@_builtins.property
|
|
159
158
|
@pulumi.getter(name="commonName")
|
|
160
|
-
def common_name(self) -> pulumi.Input[
|
|
159
|
+
def common_name(self) -> pulumi.Input[_builtins.str]:
|
|
161
160
|
"""
|
|
162
161
|
CN of intermediate to create
|
|
163
162
|
"""
|
|
164
163
|
return pulumi.get(self, "common_name")
|
|
165
164
|
|
|
166
165
|
@common_name.setter
|
|
167
|
-
def common_name(self, value: pulumi.Input[
|
|
166
|
+
def common_name(self, value: pulumi.Input[_builtins.str]):
|
|
168
167
|
pulumi.set(self, "common_name", value)
|
|
169
168
|
|
|
170
|
-
@property
|
|
169
|
+
@_builtins.property
|
|
171
170
|
@pulumi.getter
|
|
172
|
-
def type(self) -> pulumi.Input[
|
|
171
|
+
def type(self) -> pulumi.Input[_builtins.str]:
|
|
173
172
|
"""
|
|
174
173
|
Type of intermediate to create. Must be either \\"exported\\" or \\"internal\\"
|
|
175
174
|
or \\"kms\\"
|
|
@@ -177,12 +176,12 @@ class SecretBackendIntermediateCertRequestArgs:
|
|
|
177
176
|
return pulumi.get(self, "type")
|
|
178
177
|
|
|
179
178
|
@type.setter
|
|
180
|
-
def type(self, value: pulumi.Input[
|
|
179
|
+
def type(self, value: pulumi.Input[_builtins.str]):
|
|
181
180
|
pulumi.set(self, "type", value)
|
|
182
181
|
|
|
183
|
-
@property
|
|
182
|
+
@_builtins.property
|
|
184
183
|
@pulumi.getter(name="addBasicConstraints")
|
|
185
|
-
def add_basic_constraints(self) -> Optional[pulumi.Input[
|
|
184
|
+
def add_basic_constraints(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
186
185
|
"""
|
|
187
186
|
Adds a Basic Constraints extension with 'CA: true'.
|
|
188
187
|
Only needed as a workaround in some compatibility scenarios with Active Directory
|
|
@@ -191,84 +190,84 @@ class SecretBackendIntermediateCertRequestArgs:
|
|
|
191
190
|
return pulumi.get(self, "add_basic_constraints")
|
|
192
191
|
|
|
193
192
|
@add_basic_constraints.setter
|
|
194
|
-
def add_basic_constraints(self, value: Optional[pulumi.Input[
|
|
193
|
+
def add_basic_constraints(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
195
194
|
pulumi.set(self, "add_basic_constraints", value)
|
|
196
195
|
|
|
197
|
-
@property
|
|
196
|
+
@_builtins.property
|
|
198
197
|
@pulumi.getter(name="altNames")
|
|
199
|
-
def alt_names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
198
|
+
def alt_names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
200
199
|
"""
|
|
201
200
|
List of alternative names
|
|
202
201
|
"""
|
|
203
202
|
return pulumi.get(self, "alt_names")
|
|
204
203
|
|
|
205
204
|
@alt_names.setter
|
|
206
|
-
def alt_names(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
205
|
+
def alt_names(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
207
206
|
pulumi.set(self, "alt_names", value)
|
|
208
207
|
|
|
209
|
-
@property
|
|
208
|
+
@_builtins.property
|
|
210
209
|
@pulumi.getter
|
|
211
|
-
def country(self) -> Optional[pulumi.Input[
|
|
210
|
+
def country(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
212
211
|
"""
|
|
213
212
|
The country
|
|
214
213
|
"""
|
|
215
214
|
return pulumi.get(self, "country")
|
|
216
215
|
|
|
217
216
|
@country.setter
|
|
218
|
-
def country(self, value: Optional[pulumi.Input[
|
|
217
|
+
def country(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
219
218
|
pulumi.set(self, "country", value)
|
|
220
219
|
|
|
221
|
-
@property
|
|
220
|
+
@_builtins.property
|
|
222
221
|
@pulumi.getter(name="excludeCnFromSans")
|
|
223
|
-
def exclude_cn_from_sans(self) -> Optional[pulumi.Input[
|
|
222
|
+
def exclude_cn_from_sans(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
224
223
|
"""
|
|
225
224
|
Flag to exclude CN from SANs
|
|
226
225
|
"""
|
|
227
226
|
return pulumi.get(self, "exclude_cn_from_sans")
|
|
228
227
|
|
|
229
228
|
@exclude_cn_from_sans.setter
|
|
230
|
-
def exclude_cn_from_sans(self, value: Optional[pulumi.Input[
|
|
229
|
+
def exclude_cn_from_sans(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
231
230
|
pulumi.set(self, "exclude_cn_from_sans", value)
|
|
232
231
|
|
|
233
|
-
@property
|
|
232
|
+
@_builtins.property
|
|
234
233
|
@pulumi.getter
|
|
235
|
-
def format(self) -> Optional[pulumi.Input[
|
|
234
|
+
def format(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
236
235
|
"""
|
|
237
236
|
The format of data
|
|
238
237
|
"""
|
|
239
238
|
return pulumi.get(self, "format")
|
|
240
239
|
|
|
241
240
|
@format.setter
|
|
242
|
-
def format(self, value: Optional[pulumi.Input[
|
|
241
|
+
def format(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
243
242
|
pulumi.set(self, "format", value)
|
|
244
243
|
|
|
245
|
-
@property
|
|
244
|
+
@_builtins.property
|
|
246
245
|
@pulumi.getter(name="ipSans")
|
|
247
|
-
def ip_sans(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
246
|
+
def ip_sans(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
248
247
|
"""
|
|
249
248
|
List of alternative IPs
|
|
250
249
|
"""
|
|
251
250
|
return pulumi.get(self, "ip_sans")
|
|
252
251
|
|
|
253
252
|
@ip_sans.setter
|
|
254
|
-
def ip_sans(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
253
|
+
def ip_sans(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
255
254
|
pulumi.set(self, "ip_sans", value)
|
|
256
255
|
|
|
257
|
-
@property
|
|
256
|
+
@_builtins.property
|
|
258
257
|
@pulumi.getter(name="keyBits")
|
|
259
|
-
def key_bits(self) -> Optional[pulumi.Input[
|
|
258
|
+
def key_bits(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
260
259
|
"""
|
|
261
260
|
The number of bits to use
|
|
262
261
|
"""
|
|
263
262
|
return pulumi.get(self, "key_bits")
|
|
264
263
|
|
|
265
264
|
@key_bits.setter
|
|
266
|
-
def key_bits(self, value: Optional[pulumi.Input[
|
|
265
|
+
def key_bits(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
267
266
|
pulumi.set(self, "key_bits", value)
|
|
268
267
|
|
|
269
|
-
@property
|
|
268
|
+
@_builtins.property
|
|
270
269
|
@pulumi.getter(name="keyName")
|
|
271
|
-
def key_name(self) -> Optional[pulumi.Input[
|
|
270
|
+
def key_name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
272
271
|
"""
|
|
273
272
|
When a new key is created with this request, optionally specifies
|
|
274
273
|
the name for this. The global ref `default` may not be used as a name.
|
|
@@ -276,12 +275,12 @@ class SecretBackendIntermediateCertRequestArgs:
|
|
|
276
275
|
return pulumi.get(self, "key_name")
|
|
277
276
|
|
|
278
277
|
@key_name.setter
|
|
279
|
-
def key_name(self, value: Optional[pulumi.Input[
|
|
278
|
+
def key_name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
280
279
|
pulumi.set(self, "key_name", value)
|
|
281
280
|
|
|
282
|
-
@property
|
|
281
|
+
@_builtins.property
|
|
283
282
|
@pulumi.getter(name="keyRef")
|
|
284
|
-
def key_ref(self) -> Optional[pulumi.Input[
|
|
283
|
+
def key_ref(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
285
284
|
"""
|
|
286
285
|
Specifies the key (either default, by name, or by identifier) to use
|
|
287
286
|
for generating this request. Only suitable for `type=existing` requests.
|
|
@@ -289,48 +288,48 @@ class SecretBackendIntermediateCertRequestArgs:
|
|
|
289
288
|
return pulumi.get(self, "key_ref")
|
|
290
289
|
|
|
291
290
|
@key_ref.setter
|
|
292
|
-
def key_ref(self, value: Optional[pulumi.Input[
|
|
291
|
+
def key_ref(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
293
292
|
pulumi.set(self, "key_ref", value)
|
|
294
293
|
|
|
295
|
-
@property
|
|
294
|
+
@_builtins.property
|
|
296
295
|
@pulumi.getter(name="keyType")
|
|
297
|
-
def key_type(self) -> Optional[pulumi.Input[
|
|
296
|
+
def key_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
298
297
|
"""
|
|
299
298
|
The desired key type
|
|
300
299
|
"""
|
|
301
300
|
return pulumi.get(self, "key_type")
|
|
302
301
|
|
|
303
302
|
@key_type.setter
|
|
304
|
-
def key_type(self, value: Optional[pulumi.Input[
|
|
303
|
+
def key_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
305
304
|
pulumi.set(self, "key_type", value)
|
|
306
305
|
|
|
307
|
-
@property
|
|
306
|
+
@_builtins.property
|
|
308
307
|
@pulumi.getter(name="keyUsages")
|
|
309
|
-
def key_usages(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
308
|
+
def key_usages(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
310
309
|
"""
|
|
311
310
|
Specifies key_usage to encode in the generated certificate.
|
|
312
311
|
"""
|
|
313
312
|
return pulumi.get(self, "key_usages")
|
|
314
313
|
|
|
315
314
|
@key_usages.setter
|
|
316
|
-
def key_usages(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
315
|
+
def key_usages(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
317
316
|
pulumi.set(self, "key_usages", value)
|
|
318
317
|
|
|
319
|
-
@property
|
|
318
|
+
@_builtins.property
|
|
320
319
|
@pulumi.getter
|
|
321
|
-
def locality(self) -> Optional[pulumi.Input[
|
|
320
|
+
def locality(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
322
321
|
"""
|
|
323
322
|
The locality
|
|
324
323
|
"""
|
|
325
324
|
return pulumi.get(self, "locality")
|
|
326
325
|
|
|
327
326
|
@locality.setter
|
|
328
|
-
def locality(self, value: Optional[pulumi.Input[
|
|
327
|
+
def locality(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
329
328
|
pulumi.set(self, "locality", value)
|
|
330
329
|
|
|
331
|
-
@property
|
|
330
|
+
@_builtins.property
|
|
332
331
|
@pulumi.getter(name="managedKeyId")
|
|
333
|
-
def managed_key_id(self) -> Optional[pulumi.Input[
|
|
332
|
+
def managed_key_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
334
333
|
"""
|
|
335
334
|
The ID of the previously configured managed key. This field is
|
|
336
335
|
required if `type` is `kms` and it conflicts with `managed_key_name`
|
|
@@ -338,12 +337,12 @@ class SecretBackendIntermediateCertRequestArgs:
|
|
|
338
337
|
return pulumi.get(self, "managed_key_id")
|
|
339
338
|
|
|
340
339
|
@managed_key_id.setter
|
|
341
|
-
def managed_key_id(self, value: Optional[pulumi.Input[
|
|
340
|
+
def managed_key_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
342
341
|
pulumi.set(self, "managed_key_id", value)
|
|
343
342
|
|
|
344
|
-
@property
|
|
343
|
+
@_builtins.property
|
|
345
344
|
@pulumi.getter(name="managedKeyName")
|
|
346
|
-
def managed_key_name(self) -> Optional[pulumi.Input[
|
|
345
|
+
def managed_key_name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
347
346
|
"""
|
|
348
347
|
The name of the previously configured managed key. This field is
|
|
349
348
|
required if `type` is `kms` and it conflicts with `managed_key_id`
|
|
@@ -351,12 +350,12 @@ class SecretBackendIntermediateCertRequestArgs:
|
|
|
351
350
|
return pulumi.get(self, "managed_key_name")
|
|
352
351
|
|
|
353
352
|
@managed_key_name.setter
|
|
354
|
-
def managed_key_name(self, value: Optional[pulumi.Input[
|
|
353
|
+
def managed_key_name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
355
354
|
pulumi.set(self, "managed_key_name", value)
|
|
356
355
|
|
|
357
|
-
@property
|
|
356
|
+
@_builtins.property
|
|
358
357
|
@pulumi.getter
|
|
359
|
-
def namespace(self) -> Optional[pulumi.Input[
|
|
358
|
+
def namespace(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
360
359
|
"""
|
|
361
360
|
The namespace to provision the resource in.
|
|
362
361
|
The value should not contain leading or trailing forward slashes.
|
|
@@ -366,209 +365,209 @@ class SecretBackendIntermediateCertRequestArgs:
|
|
|
366
365
|
return pulumi.get(self, "namespace")
|
|
367
366
|
|
|
368
367
|
@namespace.setter
|
|
369
|
-
def namespace(self, value: Optional[pulumi.Input[
|
|
368
|
+
def namespace(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
370
369
|
pulumi.set(self, "namespace", value)
|
|
371
370
|
|
|
372
|
-
@property
|
|
371
|
+
@_builtins.property
|
|
373
372
|
@pulumi.getter
|
|
374
|
-
def organization(self) -> Optional[pulumi.Input[
|
|
373
|
+
def organization(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
375
374
|
"""
|
|
376
375
|
The organization
|
|
377
376
|
"""
|
|
378
377
|
return pulumi.get(self, "organization")
|
|
379
378
|
|
|
380
379
|
@organization.setter
|
|
381
|
-
def organization(self, value: Optional[pulumi.Input[
|
|
380
|
+
def organization(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
382
381
|
pulumi.set(self, "organization", value)
|
|
383
382
|
|
|
384
|
-
@property
|
|
383
|
+
@_builtins.property
|
|
385
384
|
@pulumi.getter(name="otherSans")
|
|
386
|
-
def other_sans(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
385
|
+
def other_sans(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
387
386
|
"""
|
|
388
387
|
List of other SANs
|
|
389
388
|
"""
|
|
390
389
|
return pulumi.get(self, "other_sans")
|
|
391
390
|
|
|
392
391
|
@other_sans.setter
|
|
393
|
-
def other_sans(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
392
|
+
def other_sans(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
394
393
|
pulumi.set(self, "other_sans", value)
|
|
395
394
|
|
|
396
|
-
@property
|
|
395
|
+
@_builtins.property
|
|
397
396
|
@pulumi.getter
|
|
398
|
-
def ou(self) -> Optional[pulumi.Input[
|
|
397
|
+
def ou(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
399
398
|
"""
|
|
400
399
|
The organization unit
|
|
401
400
|
"""
|
|
402
401
|
return pulumi.get(self, "ou")
|
|
403
402
|
|
|
404
403
|
@ou.setter
|
|
405
|
-
def ou(self, value: Optional[pulumi.Input[
|
|
404
|
+
def ou(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
406
405
|
pulumi.set(self, "ou", value)
|
|
407
406
|
|
|
408
|
-
@property
|
|
407
|
+
@_builtins.property
|
|
409
408
|
@pulumi.getter(name="postalCode")
|
|
410
|
-
def postal_code(self) -> Optional[pulumi.Input[
|
|
409
|
+
def postal_code(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
411
410
|
"""
|
|
412
411
|
The postal code
|
|
413
412
|
"""
|
|
414
413
|
return pulumi.get(self, "postal_code")
|
|
415
414
|
|
|
416
415
|
@postal_code.setter
|
|
417
|
-
def postal_code(self, value: Optional[pulumi.Input[
|
|
416
|
+
def postal_code(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
418
417
|
pulumi.set(self, "postal_code", value)
|
|
419
418
|
|
|
420
|
-
@property
|
|
419
|
+
@_builtins.property
|
|
421
420
|
@pulumi.getter(name="privateKeyFormat")
|
|
422
|
-
def private_key_format(self) -> Optional[pulumi.Input[
|
|
421
|
+
def private_key_format(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
423
422
|
"""
|
|
424
423
|
The private key format
|
|
425
424
|
"""
|
|
426
425
|
return pulumi.get(self, "private_key_format")
|
|
427
426
|
|
|
428
427
|
@private_key_format.setter
|
|
429
|
-
def private_key_format(self, value: Optional[pulumi.Input[
|
|
428
|
+
def private_key_format(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
430
429
|
pulumi.set(self, "private_key_format", value)
|
|
431
430
|
|
|
432
|
-
@property
|
|
431
|
+
@_builtins.property
|
|
433
432
|
@pulumi.getter
|
|
434
|
-
def province(self) -> Optional[pulumi.Input[
|
|
433
|
+
def province(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
435
434
|
"""
|
|
436
435
|
The province
|
|
437
436
|
"""
|
|
438
437
|
return pulumi.get(self, "province")
|
|
439
438
|
|
|
440
439
|
@province.setter
|
|
441
|
-
def province(self, value: Optional[pulumi.Input[
|
|
440
|
+
def province(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
442
441
|
pulumi.set(self, "province", value)
|
|
443
442
|
|
|
444
|
-
@property
|
|
443
|
+
@_builtins.property
|
|
445
444
|
@pulumi.getter(name="serialNumber")
|
|
446
|
-
def serial_number(self) -> Optional[pulumi.Input[
|
|
445
|
+
def serial_number(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
447
446
|
"""
|
|
448
447
|
The requested Subject's named Serial Number
|
|
449
448
|
"""
|
|
450
449
|
return pulumi.get(self, "serial_number")
|
|
451
450
|
|
|
452
451
|
@serial_number.setter
|
|
453
|
-
def serial_number(self, value: Optional[pulumi.Input[
|
|
452
|
+
def serial_number(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
454
453
|
pulumi.set(self, "serial_number", value)
|
|
455
454
|
|
|
456
|
-
@property
|
|
455
|
+
@_builtins.property
|
|
457
456
|
@pulumi.getter(name="signatureBits")
|
|
458
|
-
def signature_bits(self) -> Optional[pulumi.Input[
|
|
457
|
+
def signature_bits(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
459
458
|
"""
|
|
460
459
|
The number of bits to use in the signature algorithm
|
|
461
460
|
"""
|
|
462
461
|
return pulumi.get(self, "signature_bits")
|
|
463
462
|
|
|
464
463
|
@signature_bits.setter
|
|
465
|
-
def signature_bits(self, value: Optional[pulumi.Input[
|
|
464
|
+
def signature_bits(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
466
465
|
pulumi.set(self, "signature_bits", value)
|
|
467
466
|
|
|
468
|
-
@property
|
|
467
|
+
@_builtins.property
|
|
469
468
|
@pulumi.getter(name="streetAddress")
|
|
470
|
-
def street_address(self) -> Optional[pulumi.Input[
|
|
469
|
+
def street_address(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
471
470
|
"""
|
|
472
471
|
The street address
|
|
473
472
|
"""
|
|
474
473
|
return pulumi.get(self, "street_address")
|
|
475
474
|
|
|
476
475
|
@street_address.setter
|
|
477
|
-
def street_address(self, value: Optional[pulumi.Input[
|
|
476
|
+
def street_address(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
478
477
|
pulumi.set(self, "street_address", value)
|
|
479
478
|
|
|
480
|
-
@property
|
|
479
|
+
@_builtins.property
|
|
481
480
|
@pulumi.getter(name="uriSans")
|
|
482
|
-
def uri_sans(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
481
|
+
def uri_sans(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
483
482
|
"""
|
|
484
483
|
List of alternative URIs
|
|
485
484
|
"""
|
|
486
485
|
return pulumi.get(self, "uri_sans")
|
|
487
486
|
|
|
488
487
|
@uri_sans.setter
|
|
489
|
-
def uri_sans(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
488
|
+
def uri_sans(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
490
489
|
pulumi.set(self, "uri_sans", value)
|
|
491
490
|
|
|
492
491
|
|
|
493
492
|
@pulumi.input_type
|
|
494
493
|
class _SecretBackendIntermediateCertRequestState:
|
|
495
494
|
def __init__(__self__, *,
|
|
496
|
-
add_basic_constraints: Optional[pulumi.Input[
|
|
497
|
-
alt_names: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
498
|
-
backend: Optional[pulumi.Input[
|
|
499
|
-
common_name: Optional[pulumi.Input[
|
|
500
|
-
country: Optional[pulumi.Input[
|
|
501
|
-
csr: Optional[pulumi.Input[
|
|
502
|
-
exclude_cn_from_sans: Optional[pulumi.Input[
|
|
503
|
-
format: Optional[pulumi.Input[
|
|
504
|
-
ip_sans: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
505
|
-
key_bits: Optional[pulumi.Input[
|
|
506
|
-
key_id: Optional[pulumi.Input[
|
|
507
|
-
key_name: Optional[pulumi.Input[
|
|
508
|
-
key_ref: Optional[pulumi.Input[
|
|
509
|
-
key_type: Optional[pulumi.Input[
|
|
510
|
-
key_usages: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
511
|
-
locality: Optional[pulumi.Input[
|
|
512
|
-
managed_key_id: Optional[pulumi.Input[
|
|
513
|
-
managed_key_name: Optional[pulumi.Input[
|
|
514
|
-
namespace: Optional[pulumi.Input[
|
|
515
|
-
organization: Optional[pulumi.Input[
|
|
516
|
-
other_sans: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
517
|
-
ou: Optional[pulumi.Input[
|
|
518
|
-
postal_code: Optional[pulumi.Input[
|
|
519
|
-
private_key: Optional[pulumi.Input[
|
|
520
|
-
private_key_format: Optional[pulumi.Input[
|
|
521
|
-
private_key_type: Optional[pulumi.Input[
|
|
522
|
-
province: Optional[pulumi.Input[
|
|
523
|
-
serial_number: Optional[pulumi.Input[
|
|
524
|
-
signature_bits: Optional[pulumi.Input[
|
|
525
|
-
street_address: Optional[pulumi.Input[
|
|
526
|
-
type: Optional[pulumi.Input[
|
|
527
|
-
uri_sans: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
495
|
+
add_basic_constraints: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
496
|
+
alt_names: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
497
|
+
backend: Optional[pulumi.Input[_builtins.str]] = None,
|
|
498
|
+
common_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
499
|
+
country: Optional[pulumi.Input[_builtins.str]] = None,
|
|
500
|
+
csr: Optional[pulumi.Input[_builtins.str]] = None,
|
|
501
|
+
exclude_cn_from_sans: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
502
|
+
format: Optional[pulumi.Input[_builtins.str]] = None,
|
|
503
|
+
ip_sans: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
504
|
+
key_bits: Optional[pulumi.Input[_builtins.int]] = None,
|
|
505
|
+
key_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
506
|
+
key_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
507
|
+
key_ref: Optional[pulumi.Input[_builtins.str]] = None,
|
|
508
|
+
key_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
509
|
+
key_usages: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
510
|
+
locality: Optional[pulumi.Input[_builtins.str]] = None,
|
|
511
|
+
managed_key_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
512
|
+
managed_key_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
513
|
+
namespace: Optional[pulumi.Input[_builtins.str]] = None,
|
|
514
|
+
organization: Optional[pulumi.Input[_builtins.str]] = None,
|
|
515
|
+
other_sans: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
516
|
+
ou: Optional[pulumi.Input[_builtins.str]] = None,
|
|
517
|
+
postal_code: Optional[pulumi.Input[_builtins.str]] = None,
|
|
518
|
+
private_key: Optional[pulumi.Input[_builtins.str]] = None,
|
|
519
|
+
private_key_format: Optional[pulumi.Input[_builtins.str]] = None,
|
|
520
|
+
private_key_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
521
|
+
province: Optional[pulumi.Input[_builtins.str]] = None,
|
|
522
|
+
serial_number: Optional[pulumi.Input[_builtins.str]] = None,
|
|
523
|
+
signature_bits: Optional[pulumi.Input[_builtins.int]] = None,
|
|
524
|
+
street_address: Optional[pulumi.Input[_builtins.str]] = None,
|
|
525
|
+
type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
526
|
+
uri_sans: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
|
|
528
527
|
"""
|
|
529
528
|
Input properties used for looking up and filtering SecretBackendIntermediateCertRequest resources.
|
|
530
|
-
:param pulumi.Input[
|
|
529
|
+
:param pulumi.Input[_builtins.bool] add_basic_constraints: Adds a Basic Constraints extension with 'CA: true'.
|
|
531
530
|
Only needed as a workaround in some compatibility scenarios with Active Directory
|
|
532
531
|
Certificate Services
|
|
533
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
534
|
-
:param pulumi.Input[
|
|
535
|
-
:param pulumi.Input[
|
|
536
|
-
:param pulumi.Input[
|
|
537
|
-
:param pulumi.Input[
|
|
538
|
-
:param pulumi.Input[
|
|
539
|
-
:param pulumi.Input[
|
|
540
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
541
|
-
:param pulumi.Input[
|
|
542
|
-
:param pulumi.Input[
|
|
543
|
-
:param pulumi.Input[
|
|
532
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] alt_names: List of alternative names
|
|
533
|
+
:param pulumi.Input[_builtins.str] backend: The PKI secret backend the resource belongs to.
|
|
534
|
+
:param pulumi.Input[_builtins.str] common_name: CN of intermediate to create
|
|
535
|
+
:param pulumi.Input[_builtins.str] country: The country
|
|
536
|
+
:param pulumi.Input[_builtins.str] csr: The CSR
|
|
537
|
+
:param pulumi.Input[_builtins.bool] exclude_cn_from_sans: Flag to exclude CN from SANs
|
|
538
|
+
:param pulumi.Input[_builtins.str] format: The format of data
|
|
539
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] ip_sans: List of alternative IPs
|
|
540
|
+
:param pulumi.Input[_builtins.int] key_bits: The number of bits to use
|
|
541
|
+
:param pulumi.Input[_builtins.str] key_id: The ID of the generated key.
|
|
542
|
+
:param pulumi.Input[_builtins.str] key_name: When a new key is created with this request, optionally specifies
|
|
544
543
|
the name for this. The global ref `default` may not be used as a name.
|
|
545
|
-
:param pulumi.Input[
|
|
544
|
+
:param pulumi.Input[_builtins.str] key_ref: Specifies the key (either default, by name, or by identifier) to use
|
|
546
545
|
for generating this request. Only suitable for `type=existing` requests.
|
|
547
|
-
:param pulumi.Input[
|
|
548
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
549
|
-
:param pulumi.Input[
|
|
550
|
-
:param pulumi.Input[
|
|
546
|
+
:param pulumi.Input[_builtins.str] key_type: The desired key type
|
|
547
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] key_usages: Specifies key_usage to encode in the generated certificate.
|
|
548
|
+
:param pulumi.Input[_builtins.str] locality: The locality
|
|
549
|
+
:param pulumi.Input[_builtins.str] managed_key_id: The ID of the previously configured managed key. This field is
|
|
551
550
|
required if `type` is `kms` and it conflicts with `managed_key_name`
|
|
552
|
-
:param pulumi.Input[
|
|
551
|
+
:param pulumi.Input[_builtins.str] managed_key_name: The name of the previously configured managed key. This field is
|
|
553
552
|
required if `type` is `kms` and it conflicts with `managed_key_id`
|
|
554
|
-
:param pulumi.Input[
|
|
553
|
+
:param pulumi.Input[_builtins.str] namespace: The namespace to provision the resource in.
|
|
555
554
|
The value should not contain leading or trailing forward slashes.
|
|
556
555
|
The `namespace` is always relative to the provider's configured [namespace](https://www.terraform.io/docs/providers/vault/index.html#namespace).
|
|
557
556
|
*Available only for Vault Enterprise*.
|
|
558
|
-
:param pulumi.Input[
|
|
559
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
560
|
-
:param pulumi.Input[
|
|
561
|
-
:param pulumi.Input[
|
|
562
|
-
:param pulumi.Input[
|
|
563
|
-
:param pulumi.Input[
|
|
564
|
-
:param pulumi.Input[
|
|
565
|
-
:param pulumi.Input[
|
|
566
|
-
:param pulumi.Input[
|
|
567
|
-
:param pulumi.Input[
|
|
568
|
-
:param pulumi.Input[
|
|
569
|
-
:param pulumi.Input[
|
|
557
|
+
:param pulumi.Input[_builtins.str] organization: The organization
|
|
558
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] other_sans: List of other SANs
|
|
559
|
+
:param pulumi.Input[_builtins.str] ou: The organization unit
|
|
560
|
+
:param pulumi.Input[_builtins.str] postal_code: The postal code
|
|
561
|
+
:param pulumi.Input[_builtins.str] private_key: The private key
|
|
562
|
+
:param pulumi.Input[_builtins.str] private_key_format: The private key format
|
|
563
|
+
:param pulumi.Input[_builtins.str] private_key_type: The private key type
|
|
564
|
+
:param pulumi.Input[_builtins.str] province: The province
|
|
565
|
+
:param pulumi.Input[_builtins.str] serial_number: The requested Subject's named Serial Number
|
|
566
|
+
:param pulumi.Input[_builtins.int] signature_bits: The number of bits to use in the signature algorithm
|
|
567
|
+
:param pulumi.Input[_builtins.str] street_address: The street address
|
|
568
|
+
:param pulumi.Input[_builtins.str] type: Type of intermediate to create. Must be either \\"exported\\" or \\"internal\\"
|
|
570
569
|
or \\"kms\\"
|
|
571
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
570
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] uri_sans: List of alternative URIs
|
|
572
571
|
"""
|
|
573
572
|
if add_basic_constraints is not None:
|
|
574
573
|
pulumi.set(__self__, "add_basic_constraints", add_basic_constraints)
|
|
@@ -635,9 +634,9 @@ class _SecretBackendIntermediateCertRequestState:
|
|
|
635
634
|
if uri_sans is not None:
|
|
636
635
|
pulumi.set(__self__, "uri_sans", uri_sans)
|
|
637
636
|
|
|
638
|
-
@property
|
|
637
|
+
@_builtins.property
|
|
639
638
|
@pulumi.getter(name="addBasicConstraints")
|
|
640
|
-
def add_basic_constraints(self) -> Optional[pulumi.Input[
|
|
639
|
+
def add_basic_constraints(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
641
640
|
"""
|
|
642
641
|
Adds a Basic Constraints extension with 'CA: true'.
|
|
643
642
|
Only needed as a workaround in some compatibility scenarios with Active Directory
|
|
@@ -646,132 +645,132 @@ class _SecretBackendIntermediateCertRequestState:
|
|
|
646
645
|
return pulumi.get(self, "add_basic_constraints")
|
|
647
646
|
|
|
648
647
|
@add_basic_constraints.setter
|
|
649
|
-
def add_basic_constraints(self, value: Optional[pulumi.Input[
|
|
648
|
+
def add_basic_constraints(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
650
649
|
pulumi.set(self, "add_basic_constraints", value)
|
|
651
650
|
|
|
652
|
-
@property
|
|
651
|
+
@_builtins.property
|
|
653
652
|
@pulumi.getter(name="altNames")
|
|
654
|
-
def alt_names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
653
|
+
def alt_names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
655
654
|
"""
|
|
656
655
|
List of alternative names
|
|
657
656
|
"""
|
|
658
657
|
return pulumi.get(self, "alt_names")
|
|
659
658
|
|
|
660
659
|
@alt_names.setter
|
|
661
|
-
def alt_names(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
660
|
+
def alt_names(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
662
661
|
pulumi.set(self, "alt_names", value)
|
|
663
662
|
|
|
664
|
-
@property
|
|
663
|
+
@_builtins.property
|
|
665
664
|
@pulumi.getter
|
|
666
|
-
def backend(self) -> Optional[pulumi.Input[
|
|
665
|
+
def backend(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
667
666
|
"""
|
|
668
667
|
The PKI secret backend the resource belongs to.
|
|
669
668
|
"""
|
|
670
669
|
return pulumi.get(self, "backend")
|
|
671
670
|
|
|
672
671
|
@backend.setter
|
|
673
|
-
def backend(self, value: Optional[pulumi.Input[
|
|
672
|
+
def backend(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
674
673
|
pulumi.set(self, "backend", value)
|
|
675
674
|
|
|
676
|
-
@property
|
|
675
|
+
@_builtins.property
|
|
677
676
|
@pulumi.getter(name="commonName")
|
|
678
|
-
def common_name(self) -> Optional[pulumi.Input[
|
|
677
|
+
def common_name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
679
678
|
"""
|
|
680
679
|
CN of intermediate to create
|
|
681
680
|
"""
|
|
682
681
|
return pulumi.get(self, "common_name")
|
|
683
682
|
|
|
684
683
|
@common_name.setter
|
|
685
|
-
def common_name(self, value: Optional[pulumi.Input[
|
|
684
|
+
def common_name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
686
685
|
pulumi.set(self, "common_name", value)
|
|
687
686
|
|
|
688
|
-
@property
|
|
687
|
+
@_builtins.property
|
|
689
688
|
@pulumi.getter
|
|
690
|
-
def country(self) -> Optional[pulumi.Input[
|
|
689
|
+
def country(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
691
690
|
"""
|
|
692
691
|
The country
|
|
693
692
|
"""
|
|
694
693
|
return pulumi.get(self, "country")
|
|
695
694
|
|
|
696
695
|
@country.setter
|
|
697
|
-
def country(self, value: Optional[pulumi.Input[
|
|
696
|
+
def country(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
698
697
|
pulumi.set(self, "country", value)
|
|
699
698
|
|
|
700
|
-
@property
|
|
699
|
+
@_builtins.property
|
|
701
700
|
@pulumi.getter
|
|
702
|
-
def csr(self) -> Optional[pulumi.Input[
|
|
701
|
+
def csr(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
703
702
|
"""
|
|
704
703
|
The CSR
|
|
705
704
|
"""
|
|
706
705
|
return pulumi.get(self, "csr")
|
|
707
706
|
|
|
708
707
|
@csr.setter
|
|
709
|
-
def csr(self, value: Optional[pulumi.Input[
|
|
708
|
+
def csr(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
710
709
|
pulumi.set(self, "csr", value)
|
|
711
710
|
|
|
712
|
-
@property
|
|
711
|
+
@_builtins.property
|
|
713
712
|
@pulumi.getter(name="excludeCnFromSans")
|
|
714
|
-
def exclude_cn_from_sans(self) -> Optional[pulumi.Input[
|
|
713
|
+
def exclude_cn_from_sans(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
715
714
|
"""
|
|
716
715
|
Flag to exclude CN from SANs
|
|
717
716
|
"""
|
|
718
717
|
return pulumi.get(self, "exclude_cn_from_sans")
|
|
719
718
|
|
|
720
719
|
@exclude_cn_from_sans.setter
|
|
721
|
-
def exclude_cn_from_sans(self, value: Optional[pulumi.Input[
|
|
720
|
+
def exclude_cn_from_sans(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
722
721
|
pulumi.set(self, "exclude_cn_from_sans", value)
|
|
723
722
|
|
|
724
|
-
@property
|
|
723
|
+
@_builtins.property
|
|
725
724
|
@pulumi.getter
|
|
726
|
-
def format(self) -> Optional[pulumi.Input[
|
|
725
|
+
def format(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
727
726
|
"""
|
|
728
727
|
The format of data
|
|
729
728
|
"""
|
|
730
729
|
return pulumi.get(self, "format")
|
|
731
730
|
|
|
732
731
|
@format.setter
|
|
733
|
-
def format(self, value: Optional[pulumi.Input[
|
|
732
|
+
def format(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
734
733
|
pulumi.set(self, "format", value)
|
|
735
734
|
|
|
736
|
-
@property
|
|
735
|
+
@_builtins.property
|
|
737
736
|
@pulumi.getter(name="ipSans")
|
|
738
|
-
def ip_sans(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
737
|
+
def ip_sans(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
739
738
|
"""
|
|
740
739
|
List of alternative IPs
|
|
741
740
|
"""
|
|
742
741
|
return pulumi.get(self, "ip_sans")
|
|
743
742
|
|
|
744
743
|
@ip_sans.setter
|
|
745
|
-
def ip_sans(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
744
|
+
def ip_sans(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
746
745
|
pulumi.set(self, "ip_sans", value)
|
|
747
746
|
|
|
748
|
-
@property
|
|
747
|
+
@_builtins.property
|
|
749
748
|
@pulumi.getter(name="keyBits")
|
|
750
|
-
def key_bits(self) -> Optional[pulumi.Input[
|
|
749
|
+
def key_bits(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
751
750
|
"""
|
|
752
751
|
The number of bits to use
|
|
753
752
|
"""
|
|
754
753
|
return pulumi.get(self, "key_bits")
|
|
755
754
|
|
|
756
755
|
@key_bits.setter
|
|
757
|
-
def key_bits(self, value: Optional[pulumi.Input[
|
|
756
|
+
def key_bits(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
758
757
|
pulumi.set(self, "key_bits", value)
|
|
759
758
|
|
|
760
|
-
@property
|
|
759
|
+
@_builtins.property
|
|
761
760
|
@pulumi.getter(name="keyId")
|
|
762
|
-
def key_id(self) -> Optional[pulumi.Input[
|
|
761
|
+
def key_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
763
762
|
"""
|
|
764
763
|
The ID of the generated key.
|
|
765
764
|
"""
|
|
766
765
|
return pulumi.get(self, "key_id")
|
|
767
766
|
|
|
768
767
|
@key_id.setter
|
|
769
|
-
def key_id(self, value: Optional[pulumi.Input[
|
|
768
|
+
def key_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
770
769
|
pulumi.set(self, "key_id", value)
|
|
771
770
|
|
|
772
|
-
@property
|
|
771
|
+
@_builtins.property
|
|
773
772
|
@pulumi.getter(name="keyName")
|
|
774
|
-
def key_name(self) -> Optional[pulumi.Input[
|
|
773
|
+
def key_name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
775
774
|
"""
|
|
776
775
|
When a new key is created with this request, optionally specifies
|
|
777
776
|
the name for this. The global ref `default` may not be used as a name.
|
|
@@ -779,12 +778,12 @@ class _SecretBackendIntermediateCertRequestState:
|
|
|
779
778
|
return pulumi.get(self, "key_name")
|
|
780
779
|
|
|
781
780
|
@key_name.setter
|
|
782
|
-
def key_name(self, value: Optional[pulumi.Input[
|
|
781
|
+
def key_name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
783
782
|
pulumi.set(self, "key_name", value)
|
|
784
783
|
|
|
785
|
-
@property
|
|
784
|
+
@_builtins.property
|
|
786
785
|
@pulumi.getter(name="keyRef")
|
|
787
|
-
def key_ref(self) -> Optional[pulumi.Input[
|
|
786
|
+
def key_ref(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
788
787
|
"""
|
|
789
788
|
Specifies the key (either default, by name, or by identifier) to use
|
|
790
789
|
for generating this request. Only suitable for `type=existing` requests.
|
|
@@ -792,48 +791,48 @@ class _SecretBackendIntermediateCertRequestState:
|
|
|
792
791
|
return pulumi.get(self, "key_ref")
|
|
793
792
|
|
|
794
793
|
@key_ref.setter
|
|
795
|
-
def key_ref(self, value: Optional[pulumi.Input[
|
|
794
|
+
def key_ref(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
796
795
|
pulumi.set(self, "key_ref", value)
|
|
797
796
|
|
|
798
|
-
@property
|
|
797
|
+
@_builtins.property
|
|
799
798
|
@pulumi.getter(name="keyType")
|
|
800
|
-
def key_type(self) -> Optional[pulumi.Input[
|
|
799
|
+
def key_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
801
800
|
"""
|
|
802
801
|
The desired key type
|
|
803
802
|
"""
|
|
804
803
|
return pulumi.get(self, "key_type")
|
|
805
804
|
|
|
806
805
|
@key_type.setter
|
|
807
|
-
def key_type(self, value: Optional[pulumi.Input[
|
|
806
|
+
def key_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
808
807
|
pulumi.set(self, "key_type", value)
|
|
809
808
|
|
|
810
|
-
@property
|
|
809
|
+
@_builtins.property
|
|
811
810
|
@pulumi.getter(name="keyUsages")
|
|
812
|
-
def key_usages(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
811
|
+
def key_usages(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
813
812
|
"""
|
|
814
813
|
Specifies key_usage to encode in the generated certificate.
|
|
815
814
|
"""
|
|
816
815
|
return pulumi.get(self, "key_usages")
|
|
817
816
|
|
|
818
817
|
@key_usages.setter
|
|
819
|
-
def key_usages(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
818
|
+
def key_usages(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
820
819
|
pulumi.set(self, "key_usages", value)
|
|
821
820
|
|
|
822
|
-
@property
|
|
821
|
+
@_builtins.property
|
|
823
822
|
@pulumi.getter
|
|
824
|
-
def locality(self) -> Optional[pulumi.Input[
|
|
823
|
+
def locality(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
825
824
|
"""
|
|
826
825
|
The locality
|
|
827
826
|
"""
|
|
828
827
|
return pulumi.get(self, "locality")
|
|
829
828
|
|
|
830
829
|
@locality.setter
|
|
831
|
-
def locality(self, value: Optional[pulumi.Input[
|
|
830
|
+
def locality(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
832
831
|
pulumi.set(self, "locality", value)
|
|
833
832
|
|
|
834
|
-
@property
|
|
833
|
+
@_builtins.property
|
|
835
834
|
@pulumi.getter(name="managedKeyId")
|
|
836
|
-
def managed_key_id(self) -> Optional[pulumi.Input[
|
|
835
|
+
def managed_key_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
837
836
|
"""
|
|
838
837
|
The ID of the previously configured managed key. This field is
|
|
839
838
|
required if `type` is `kms` and it conflicts with `managed_key_name`
|
|
@@ -841,12 +840,12 @@ class _SecretBackendIntermediateCertRequestState:
|
|
|
841
840
|
return pulumi.get(self, "managed_key_id")
|
|
842
841
|
|
|
843
842
|
@managed_key_id.setter
|
|
844
|
-
def managed_key_id(self, value: Optional[pulumi.Input[
|
|
843
|
+
def managed_key_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
845
844
|
pulumi.set(self, "managed_key_id", value)
|
|
846
845
|
|
|
847
|
-
@property
|
|
846
|
+
@_builtins.property
|
|
848
847
|
@pulumi.getter(name="managedKeyName")
|
|
849
|
-
def managed_key_name(self) -> Optional[pulumi.Input[
|
|
848
|
+
def managed_key_name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
850
849
|
"""
|
|
851
850
|
The name of the previously configured managed key. This field is
|
|
852
851
|
required if `type` is `kms` and it conflicts with `managed_key_id`
|
|
@@ -854,12 +853,12 @@ class _SecretBackendIntermediateCertRequestState:
|
|
|
854
853
|
return pulumi.get(self, "managed_key_name")
|
|
855
854
|
|
|
856
855
|
@managed_key_name.setter
|
|
857
|
-
def managed_key_name(self, value: Optional[pulumi.Input[
|
|
856
|
+
def managed_key_name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
858
857
|
pulumi.set(self, "managed_key_name", value)
|
|
859
858
|
|
|
860
|
-
@property
|
|
859
|
+
@_builtins.property
|
|
861
860
|
@pulumi.getter
|
|
862
|
-
def namespace(self) -> Optional[pulumi.Input[
|
|
861
|
+
def namespace(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
863
862
|
"""
|
|
864
863
|
The namespace to provision the resource in.
|
|
865
864
|
The value should not contain leading or trailing forward slashes.
|
|
@@ -869,144 +868,144 @@ class _SecretBackendIntermediateCertRequestState:
|
|
|
869
868
|
return pulumi.get(self, "namespace")
|
|
870
869
|
|
|
871
870
|
@namespace.setter
|
|
872
|
-
def namespace(self, value: Optional[pulumi.Input[
|
|
871
|
+
def namespace(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
873
872
|
pulumi.set(self, "namespace", value)
|
|
874
873
|
|
|
875
|
-
@property
|
|
874
|
+
@_builtins.property
|
|
876
875
|
@pulumi.getter
|
|
877
|
-
def organization(self) -> Optional[pulumi.Input[
|
|
876
|
+
def organization(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
878
877
|
"""
|
|
879
878
|
The organization
|
|
880
879
|
"""
|
|
881
880
|
return pulumi.get(self, "organization")
|
|
882
881
|
|
|
883
882
|
@organization.setter
|
|
884
|
-
def organization(self, value: Optional[pulumi.Input[
|
|
883
|
+
def organization(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
885
884
|
pulumi.set(self, "organization", value)
|
|
886
885
|
|
|
887
|
-
@property
|
|
886
|
+
@_builtins.property
|
|
888
887
|
@pulumi.getter(name="otherSans")
|
|
889
|
-
def other_sans(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
888
|
+
def other_sans(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
890
889
|
"""
|
|
891
890
|
List of other SANs
|
|
892
891
|
"""
|
|
893
892
|
return pulumi.get(self, "other_sans")
|
|
894
893
|
|
|
895
894
|
@other_sans.setter
|
|
896
|
-
def other_sans(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
895
|
+
def other_sans(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
897
896
|
pulumi.set(self, "other_sans", value)
|
|
898
897
|
|
|
899
|
-
@property
|
|
898
|
+
@_builtins.property
|
|
900
899
|
@pulumi.getter
|
|
901
|
-
def ou(self) -> Optional[pulumi.Input[
|
|
900
|
+
def ou(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
902
901
|
"""
|
|
903
902
|
The organization unit
|
|
904
903
|
"""
|
|
905
904
|
return pulumi.get(self, "ou")
|
|
906
905
|
|
|
907
906
|
@ou.setter
|
|
908
|
-
def ou(self, value: Optional[pulumi.Input[
|
|
907
|
+
def ou(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
909
908
|
pulumi.set(self, "ou", value)
|
|
910
909
|
|
|
911
|
-
@property
|
|
910
|
+
@_builtins.property
|
|
912
911
|
@pulumi.getter(name="postalCode")
|
|
913
|
-
def postal_code(self) -> Optional[pulumi.Input[
|
|
912
|
+
def postal_code(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
914
913
|
"""
|
|
915
914
|
The postal code
|
|
916
915
|
"""
|
|
917
916
|
return pulumi.get(self, "postal_code")
|
|
918
917
|
|
|
919
918
|
@postal_code.setter
|
|
920
|
-
def postal_code(self, value: Optional[pulumi.Input[
|
|
919
|
+
def postal_code(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
921
920
|
pulumi.set(self, "postal_code", value)
|
|
922
921
|
|
|
923
|
-
@property
|
|
922
|
+
@_builtins.property
|
|
924
923
|
@pulumi.getter(name="privateKey")
|
|
925
|
-
def private_key(self) -> Optional[pulumi.Input[
|
|
924
|
+
def private_key(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
926
925
|
"""
|
|
927
926
|
The private key
|
|
928
927
|
"""
|
|
929
928
|
return pulumi.get(self, "private_key")
|
|
930
929
|
|
|
931
930
|
@private_key.setter
|
|
932
|
-
def private_key(self, value: Optional[pulumi.Input[
|
|
931
|
+
def private_key(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
933
932
|
pulumi.set(self, "private_key", value)
|
|
934
933
|
|
|
935
|
-
@property
|
|
934
|
+
@_builtins.property
|
|
936
935
|
@pulumi.getter(name="privateKeyFormat")
|
|
937
|
-
def private_key_format(self) -> Optional[pulumi.Input[
|
|
936
|
+
def private_key_format(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
938
937
|
"""
|
|
939
938
|
The private key format
|
|
940
939
|
"""
|
|
941
940
|
return pulumi.get(self, "private_key_format")
|
|
942
941
|
|
|
943
942
|
@private_key_format.setter
|
|
944
|
-
def private_key_format(self, value: Optional[pulumi.Input[
|
|
943
|
+
def private_key_format(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
945
944
|
pulumi.set(self, "private_key_format", value)
|
|
946
945
|
|
|
947
|
-
@property
|
|
946
|
+
@_builtins.property
|
|
948
947
|
@pulumi.getter(name="privateKeyType")
|
|
949
|
-
def private_key_type(self) -> Optional[pulumi.Input[
|
|
948
|
+
def private_key_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
950
949
|
"""
|
|
951
950
|
The private key type
|
|
952
951
|
"""
|
|
953
952
|
return pulumi.get(self, "private_key_type")
|
|
954
953
|
|
|
955
954
|
@private_key_type.setter
|
|
956
|
-
def private_key_type(self, value: Optional[pulumi.Input[
|
|
955
|
+
def private_key_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
957
956
|
pulumi.set(self, "private_key_type", value)
|
|
958
957
|
|
|
959
|
-
@property
|
|
958
|
+
@_builtins.property
|
|
960
959
|
@pulumi.getter
|
|
961
|
-
def province(self) -> Optional[pulumi.Input[
|
|
960
|
+
def province(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
962
961
|
"""
|
|
963
962
|
The province
|
|
964
963
|
"""
|
|
965
964
|
return pulumi.get(self, "province")
|
|
966
965
|
|
|
967
966
|
@province.setter
|
|
968
|
-
def province(self, value: Optional[pulumi.Input[
|
|
967
|
+
def province(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
969
968
|
pulumi.set(self, "province", value)
|
|
970
969
|
|
|
971
|
-
@property
|
|
970
|
+
@_builtins.property
|
|
972
971
|
@pulumi.getter(name="serialNumber")
|
|
973
|
-
def serial_number(self) -> Optional[pulumi.Input[
|
|
972
|
+
def serial_number(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
974
973
|
"""
|
|
975
974
|
The requested Subject's named Serial Number
|
|
976
975
|
"""
|
|
977
976
|
return pulumi.get(self, "serial_number")
|
|
978
977
|
|
|
979
978
|
@serial_number.setter
|
|
980
|
-
def serial_number(self, value: Optional[pulumi.Input[
|
|
979
|
+
def serial_number(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
981
980
|
pulumi.set(self, "serial_number", value)
|
|
982
981
|
|
|
983
|
-
@property
|
|
982
|
+
@_builtins.property
|
|
984
983
|
@pulumi.getter(name="signatureBits")
|
|
985
|
-
def signature_bits(self) -> Optional[pulumi.Input[
|
|
984
|
+
def signature_bits(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
986
985
|
"""
|
|
987
986
|
The number of bits to use in the signature algorithm
|
|
988
987
|
"""
|
|
989
988
|
return pulumi.get(self, "signature_bits")
|
|
990
989
|
|
|
991
990
|
@signature_bits.setter
|
|
992
|
-
def signature_bits(self, value: Optional[pulumi.Input[
|
|
991
|
+
def signature_bits(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
993
992
|
pulumi.set(self, "signature_bits", value)
|
|
994
993
|
|
|
995
|
-
@property
|
|
994
|
+
@_builtins.property
|
|
996
995
|
@pulumi.getter(name="streetAddress")
|
|
997
|
-
def street_address(self) -> Optional[pulumi.Input[
|
|
996
|
+
def street_address(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
998
997
|
"""
|
|
999
998
|
The street address
|
|
1000
999
|
"""
|
|
1001
1000
|
return pulumi.get(self, "street_address")
|
|
1002
1001
|
|
|
1003
1002
|
@street_address.setter
|
|
1004
|
-
def street_address(self, value: Optional[pulumi.Input[
|
|
1003
|
+
def street_address(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1005
1004
|
pulumi.set(self, "street_address", value)
|
|
1006
1005
|
|
|
1007
|
-
@property
|
|
1006
|
+
@_builtins.property
|
|
1008
1007
|
@pulumi.getter
|
|
1009
|
-
def type(self) -> Optional[pulumi.Input[
|
|
1008
|
+
def type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1010
1009
|
"""
|
|
1011
1010
|
Type of intermediate to create. Must be either \\"exported\\" or \\"internal\\"
|
|
1012
1011
|
or \\"kms\\"
|
|
@@ -1014,19 +1013,19 @@ class _SecretBackendIntermediateCertRequestState:
|
|
|
1014
1013
|
return pulumi.get(self, "type")
|
|
1015
1014
|
|
|
1016
1015
|
@type.setter
|
|
1017
|
-
def type(self, value: Optional[pulumi.Input[
|
|
1016
|
+
def type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1018
1017
|
pulumi.set(self, "type", value)
|
|
1019
1018
|
|
|
1020
|
-
@property
|
|
1019
|
+
@_builtins.property
|
|
1021
1020
|
@pulumi.getter(name="uriSans")
|
|
1022
|
-
def uri_sans(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1021
|
+
def uri_sans(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
1023
1022
|
"""
|
|
1024
1023
|
List of alternative URIs
|
|
1025
1024
|
"""
|
|
1026
1025
|
return pulumi.get(self, "uri_sans")
|
|
1027
1026
|
|
|
1028
1027
|
@uri_sans.setter
|
|
1029
|
-
def uri_sans(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1028
|
+
def uri_sans(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
1030
1029
|
pulumi.set(self, "uri_sans", value)
|
|
1031
1030
|
|
|
1032
1031
|
|
|
@@ -1036,34 +1035,34 @@ class SecretBackendIntermediateCertRequest(pulumi.CustomResource):
|
|
|
1036
1035
|
def __init__(__self__,
|
|
1037
1036
|
resource_name: str,
|
|
1038
1037
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
1039
|
-
add_basic_constraints: Optional[pulumi.Input[
|
|
1040
|
-
alt_names: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1041
|
-
backend: Optional[pulumi.Input[
|
|
1042
|
-
common_name: Optional[pulumi.Input[
|
|
1043
|
-
country: Optional[pulumi.Input[
|
|
1044
|
-
exclude_cn_from_sans: Optional[pulumi.Input[
|
|
1045
|
-
format: Optional[pulumi.Input[
|
|
1046
|
-
ip_sans: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1047
|
-
key_bits: Optional[pulumi.Input[
|
|
1048
|
-
key_name: Optional[pulumi.Input[
|
|
1049
|
-
key_ref: Optional[pulumi.Input[
|
|
1050
|
-
key_type: Optional[pulumi.Input[
|
|
1051
|
-
key_usages: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1052
|
-
locality: Optional[pulumi.Input[
|
|
1053
|
-
managed_key_id: Optional[pulumi.Input[
|
|
1054
|
-
managed_key_name: Optional[pulumi.Input[
|
|
1055
|
-
namespace: Optional[pulumi.Input[
|
|
1056
|
-
organization: Optional[pulumi.Input[
|
|
1057
|
-
other_sans: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1058
|
-
ou: Optional[pulumi.Input[
|
|
1059
|
-
postal_code: Optional[pulumi.Input[
|
|
1060
|
-
private_key_format: Optional[pulumi.Input[
|
|
1061
|
-
province: Optional[pulumi.Input[
|
|
1062
|
-
serial_number: Optional[pulumi.Input[
|
|
1063
|
-
signature_bits: Optional[pulumi.Input[
|
|
1064
|
-
street_address: Optional[pulumi.Input[
|
|
1065
|
-
type: Optional[pulumi.Input[
|
|
1066
|
-
uri_sans: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1038
|
+
add_basic_constraints: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1039
|
+
alt_names: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1040
|
+
backend: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1041
|
+
common_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1042
|
+
country: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1043
|
+
exclude_cn_from_sans: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1044
|
+
format: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1045
|
+
ip_sans: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1046
|
+
key_bits: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1047
|
+
key_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1048
|
+
key_ref: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1049
|
+
key_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1050
|
+
key_usages: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1051
|
+
locality: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1052
|
+
managed_key_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1053
|
+
managed_key_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1054
|
+
namespace: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1055
|
+
organization: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1056
|
+
other_sans: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1057
|
+
ou: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1058
|
+
postal_code: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1059
|
+
private_key_format: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1060
|
+
province: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1061
|
+
serial_number: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1062
|
+
signature_bits: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1063
|
+
street_address: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1064
|
+
type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1065
|
+
uri_sans: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1067
1066
|
__props__=None):
|
|
1068
1067
|
"""
|
|
1069
1068
|
## Example Usage
|
|
@@ -1072,7 +1071,7 @@ class SecretBackendIntermediateCertRequest(pulumi.CustomResource):
|
|
|
1072
1071
|
import pulumi
|
|
1073
1072
|
import pulumi_vault as vault
|
|
1074
1073
|
|
|
1075
|
-
test = vault.
|
|
1074
|
+
test = vault.pkisecret.SecretBackendIntermediateCertRequest("test",
|
|
1076
1075
|
backend=pki["path"],
|
|
1077
1076
|
type="internal",
|
|
1078
1077
|
common_name="app.my.domain",
|
|
@@ -1081,44 +1080,44 @@ class SecretBackendIntermediateCertRequest(pulumi.CustomResource):
|
|
|
1081
1080
|
|
|
1082
1081
|
:param str resource_name: The name of the resource.
|
|
1083
1082
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
1084
|
-
:param pulumi.Input[
|
|
1083
|
+
:param pulumi.Input[_builtins.bool] add_basic_constraints: Adds a Basic Constraints extension with 'CA: true'.
|
|
1085
1084
|
Only needed as a workaround in some compatibility scenarios with Active Directory
|
|
1086
1085
|
Certificate Services
|
|
1087
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
1088
|
-
:param pulumi.Input[
|
|
1089
|
-
:param pulumi.Input[
|
|
1090
|
-
:param pulumi.Input[
|
|
1091
|
-
:param pulumi.Input[
|
|
1092
|
-
:param pulumi.Input[
|
|
1093
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
1094
|
-
:param pulumi.Input[
|
|
1095
|
-
:param pulumi.Input[
|
|
1086
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] alt_names: List of alternative names
|
|
1087
|
+
:param pulumi.Input[_builtins.str] backend: The PKI secret backend the resource belongs to.
|
|
1088
|
+
:param pulumi.Input[_builtins.str] common_name: CN of intermediate to create
|
|
1089
|
+
:param pulumi.Input[_builtins.str] country: The country
|
|
1090
|
+
:param pulumi.Input[_builtins.bool] exclude_cn_from_sans: Flag to exclude CN from SANs
|
|
1091
|
+
:param pulumi.Input[_builtins.str] format: The format of data
|
|
1092
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] ip_sans: List of alternative IPs
|
|
1093
|
+
:param pulumi.Input[_builtins.int] key_bits: The number of bits to use
|
|
1094
|
+
:param pulumi.Input[_builtins.str] key_name: When a new key is created with this request, optionally specifies
|
|
1096
1095
|
the name for this. The global ref `default` may not be used as a name.
|
|
1097
|
-
:param pulumi.Input[
|
|
1096
|
+
:param pulumi.Input[_builtins.str] key_ref: Specifies the key (either default, by name, or by identifier) to use
|
|
1098
1097
|
for generating this request. Only suitable for `type=existing` requests.
|
|
1099
|
-
:param pulumi.Input[
|
|
1100
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
1101
|
-
:param pulumi.Input[
|
|
1102
|
-
:param pulumi.Input[
|
|
1098
|
+
:param pulumi.Input[_builtins.str] key_type: The desired key type
|
|
1099
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] key_usages: Specifies key_usage to encode in the generated certificate.
|
|
1100
|
+
:param pulumi.Input[_builtins.str] locality: The locality
|
|
1101
|
+
:param pulumi.Input[_builtins.str] managed_key_id: The ID of the previously configured managed key. This field is
|
|
1103
1102
|
required if `type` is `kms` and it conflicts with `managed_key_name`
|
|
1104
|
-
:param pulumi.Input[
|
|
1103
|
+
:param pulumi.Input[_builtins.str] managed_key_name: The name of the previously configured managed key. This field is
|
|
1105
1104
|
required if `type` is `kms` and it conflicts with `managed_key_id`
|
|
1106
|
-
:param pulumi.Input[
|
|
1105
|
+
:param pulumi.Input[_builtins.str] namespace: The namespace to provision the resource in.
|
|
1107
1106
|
The value should not contain leading or trailing forward slashes.
|
|
1108
1107
|
The `namespace` is always relative to the provider's configured [namespace](https://www.terraform.io/docs/providers/vault/index.html#namespace).
|
|
1109
1108
|
*Available only for Vault Enterprise*.
|
|
1110
|
-
:param pulumi.Input[
|
|
1111
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
1112
|
-
:param pulumi.Input[
|
|
1113
|
-
:param pulumi.Input[
|
|
1114
|
-
:param pulumi.Input[
|
|
1115
|
-
:param pulumi.Input[
|
|
1116
|
-
:param pulumi.Input[
|
|
1117
|
-
:param pulumi.Input[
|
|
1118
|
-
:param pulumi.Input[
|
|
1119
|
-
:param pulumi.Input[
|
|
1109
|
+
:param pulumi.Input[_builtins.str] organization: The organization
|
|
1110
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] other_sans: List of other SANs
|
|
1111
|
+
:param pulumi.Input[_builtins.str] ou: The organization unit
|
|
1112
|
+
:param pulumi.Input[_builtins.str] postal_code: The postal code
|
|
1113
|
+
:param pulumi.Input[_builtins.str] private_key_format: The private key format
|
|
1114
|
+
:param pulumi.Input[_builtins.str] province: The province
|
|
1115
|
+
:param pulumi.Input[_builtins.str] serial_number: The requested Subject's named Serial Number
|
|
1116
|
+
:param pulumi.Input[_builtins.int] signature_bits: The number of bits to use in the signature algorithm
|
|
1117
|
+
:param pulumi.Input[_builtins.str] street_address: The street address
|
|
1118
|
+
:param pulumi.Input[_builtins.str] type: Type of intermediate to create. Must be either \\"exported\\" or \\"internal\\"
|
|
1120
1119
|
or \\"kms\\"
|
|
1121
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
1120
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] uri_sans: List of alternative URIs
|
|
1122
1121
|
"""
|
|
1123
1122
|
...
|
|
1124
1123
|
@overload
|
|
@@ -1133,7 +1132,7 @@ class SecretBackendIntermediateCertRequest(pulumi.CustomResource):
|
|
|
1133
1132
|
import pulumi
|
|
1134
1133
|
import pulumi_vault as vault
|
|
1135
1134
|
|
|
1136
|
-
test = vault.
|
|
1135
|
+
test = vault.pkisecret.SecretBackendIntermediateCertRequest("test",
|
|
1137
1136
|
backend=pki["path"],
|
|
1138
1137
|
type="internal",
|
|
1139
1138
|
common_name="app.my.domain",
|
|
@@ -1155,34 +1154,34 @@ class SecretBackendIntermediateCertRequest(pulumi.CustomResource):
|
|
|
1155
1154
|
def _internal_init(__self__,
|
|
1156
1155
|
resource_name: str,
|
|
1157
1156
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
1158
|
-
add_basic_constraints: Optional[pulumi.Input[
|
|
1159
|
-
alt_names: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1160
|
-
backend: Optional[pulumi.Input[
|
|
1161
|
-
common_name: Optional[pulumi.Input[
|
|
1162
|
-
country: Optional[pulumi.Input[
|
|
1163
|
-
exclude_cn_from_sans: Optional[pulumi.Input[
|
|
1164
|
-
format: Optional[pulumi.Input[
|
|
1165
|
-
ip_sans: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1166
|
-
key_bits: Optional[pulumi.Input[
|
|
1167
|
-
key_name: Optional[pulumi.Input[
|
|
1168
|
-
key_ref: Optional[pulumi.Input[
|
|
1169
|
-
key_type: Optional[pulumi.Input[
|
|
1170
|
-
key_usages: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1171
|
-
locality: Optional[pulumi.Input[
|
|
1172
|
-
managed_key_id: Optional[pulumi.Input[
|
|
1173
|
-
managed_key_name: Optional[pulumi.Input[
|
|
1174
|
-
namespace: Optional[pulumi.Input[
|
|
1175
|
-
organization: Optional[pulumi.Input[
|
|
1176
|
-
other_sans: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1177
|
-
ou: Optional[pulumi.Input[
|
|
1178
|
-
postal_code: Optional[pulumi.Input[
|
|
1179
|
-
private_key_format: Optional[pulumi.Input[
|
|
1180
|
-
province: Optional[pulumi.Input[
|
|
1181
|
-
serial_number: Optional[pulumi.Input[
|
|
1182
|
-
signature_bits: Optional[pulumi.Input[
|
|
1183
|
-
street_address: Optional[pulumi.Input[
|
|
1184
|
-
type: Optional[pulumi.Input[
|
|
1185
|
-
uri_sans: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1157
|
+
add_basic_constraints: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1158
|
+
alt_names: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1159
|
+
backend: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1160
|
+
common_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1161
|
+
country: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1162
|
+
exclude_cn_from_sans: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1163
|
+
format: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1164
|
+
ip_sans: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1165
|
+
key_bits: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1166
|
+
key_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1167
|
+
key_ref: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1168
|
+
key_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1169
|
+
key_usages: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1170
|
+
locality: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1171
|
+
managed_key_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1172
|
+
managed_key_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1173
|
+
namespace: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1174
|
+
organization: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1175
|
+
other_sans: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1176
|
+
ou: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1177
|
+
postal_code: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1178
|
+
private_key_format: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1179
|
+
province: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1180
|
+
serial_number: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1181
|
+
signature_bits: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1182
|
+
street_address: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1183
|
+
type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1184
|
+
uri_sans: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1186
1185
|
__props__=None):
|
|
1187
1186
|
opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
|
|
1188
1187
|
if not isinstance(opts, pulumi.ResourceOptions):
|
|
@@ -1242,38 +1241,38 @@ class SecretBackendIntermediateCertRequest(pulumi.CustomResource):
|
|
|
1242
1241
|
def get(resource_name: str,
|
|
1243
1242
|
id: pulumi.Input[str],
|
|
1244
1243
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
1245
|
-
add_basic_constraints: Optional[pulumi.Input[
|
|
1246
|
-
alt_names: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1247
|
-
backend: Optional[pulumi.Input[
|
|
1248
|
-
common_name: Optional[pulumi.Input[
|
|
1249
|
-
country: Optional[pulumi.Input[
|
|
1250
|
-
csr: Optional[pulumi.Input[
|
|
1251
|
-
exclude_cn_from_sans: Optional[pulumi.Input[
|
|
1252
|
-
format: Optional[pulumi.Input[
|
|
1253
|
-
ip_sans: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1254
|
-
key_bits: Optional[pulumi.Input[
|
|
1255
|
-
key_id: Optional[pulumi.Input[
|
|
1256
|
-
key_name: Optional[pulumi.Input[
|
|
1257
|
-
key_ref: Optional[pulumi.Input[
|
|
1258
|
-
key_type: Optional[pulumi.Input[
|
|
1259
|
-
key_usages: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1260
|
-
locality: Optional[pulumi.Input[
|
|
1261
|
-
managed_key_id: Optional[pulumi.Input[
|
|
1262
|
-
managed_key_name: Optional[pulumi.Input[
|
|
1263
|
-
namespace: Optional[pulumi.Input[
|
|
1264
|
-
organization: Optional[pulumi.Input[
|
|
1265
|
-
other_sans: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1266
|
-
ou: Optional[pulumi.Input[
|
|
1267
|
-
postal_code: Optional[pulumi.Input[
|
|
1268
|
-
private_key: Optional[pulumi.Input[
|
|
1269
|
-
private_key_format: Optional[pulumi.Input[
|
|
1270
|
-
private_key_type: Optional[pulumi.Input[
|
|
1271
|
-
province: Optional[pulumi.Input[
|
|
1272
|
-
serial_number: Optional[pulumi.Input[
|
|
1273
|
-
signature_bits: Optional[pulumi.Input[
|
|
1274
|
-
street_address: Optional[pulumi.Input[
|
|
1275
|
-
type: Optional[pulumi.Input[
|
|
1276
|
-
uri_sans: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1244
|
+
add_basic_constraints: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1245
|
+
alt_names: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1246
|
+
backend: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1247
|
+
common_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1248
|
+
country: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1249
|
+
csr: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1250
|
+
exclude_cn_from_sans: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1251
|
+
format: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1252
|
+
ip_sans: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1253
|
+
key_bits: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1254
|
+
key_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1255
|
+
key_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1256
|
+
key_ref: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1257
|
+
key_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1258
|
+
key_usages: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1259
|
+
locality: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1260
|
+
managed_key_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1261
|
+
managed_key_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1262
|
+
namespace: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1263
|
+
organization: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1264
|
+
other_sans: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1265
|
+
ou: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1266
|
+
postal_code: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1267
|
+
private_key: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1268
|
+
private_key_format: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1269
|
+
private_key_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1270
|
+
province: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1271
|
+
serial_number: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1272
|
+
signature_bits: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1273
|
+
street_address: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1274
|
+
type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1275
|
+
uri_sans: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None) -> 'SecretBackendIntermediateCertRequest':
|
|
1277
1276
|
"""
|
|
1278
1277
|
Get an existing SecretBackendIntermediateCertRequest resource's state with the given name, id, and optional extra
|
|
1279
1278
|
properties used to qualify the lookup.
|
|
@@ -1281,48 +1280,48 @@ class SecretBackendIntermediateCertRequest(pulumi.CustomResource):
|
|
|
1281
1280
|
:param str resource_name: The unique name of the resulting resource.
|
|
1282
1281
|
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
|
|
1283
1282
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
1284
|
-
:param pulumi.Input[
|
|
1283
|
+
:param pulumi.Input[_builtins.bool] add_basic_constraints: Adds a Basic Constraints extension with 'CA: true'.
|
|
1285
1284
|
Only needed as a workaround in some compatibility scenarios with Active Directory
|
|
1286
1285
|
Certificate Services
|
|
1287
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
1288
|
-
:param pulumi.Input[
|
|
1289
|
-
:param pulumi.Input[
|
|
1290
|
-
:param pulumi.Input[
|
|
1291
|
-
:param pulumi.Input[
|
|
1292
|
-
:param pulumi.Input[
|
|
1293
|
-
:param pulumi.Input[
|
|
1294
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
1295
|
-
:param pulumi.Input[
|
|
1296
|
-
:param pulumi.Input[
|
|
1297
|
-
:param pulumi.Input[
|
|
1286
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] alt_names: List of alternative names
|
|
1287
|
+
:param pulumi.Input[_builtins.str] backend: The PKI secret backend the resource belongs to.
|
|
1288
|
+
:param pulumi.Input[_builtins.str] common_name: CN of intermediate to create
|
|
1289
|
+
:param pulumi.Input[_builtins.str] country: The country
|
|
1290
|
+
:param pulumi.Input[_builtins.str] csr: The CSR
|
|
1291
|
+
:param pulumi.Input[_builtins.bool] exclude_cn_from_sans: Flag to exclude CN from SANs
|
|
1292
|
+
:param pulumi.Input[_builtins.str] format: The format of data
|
|
1293
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] ip_sans: List of alternative IPs
|
|
1294
|
+
:param pulumi.Input[_builtins.int] key_bits: The number of bits to use
|
|
1295
|
+
:param pulumi.Input[_builtins.str] key_id: The ID of the generated key.
|
|
1296
|
+
:param pulumi.Input[_builtins.str] key_name: When a new key is created with this request, optionally specifies
|
|
1298
1297
|
the name for this. The global ref `default` may not be used as a name.
|
|
1299
|
-
:param pulumi.Input[
|
|
1298
|
+
:param pulumi.Input[_builtins.str] key_ref: Specifies the key (either default, by name, or by identifier) to use
|
|
1300
1299
|
for generating this request. Only suitable for `type=existing` requests.
|
|
1301
|
-
:param pulumi.Input[
|
|
1302
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
1303
|
-
:param pulumi.Input[
|
|
1304
|
-
:param pulumi.Input[
|
|
1300
|
+
:param pulumi.Input[_builtins.str] key_type: The desired key type
|
|
1301
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] key_usages: Specifies key_usage to encode in the generated certificate.
|
|
1302
|
+
:param pulumi.Input[_builtins.str] locality: The locality
|
|
1303
|
+
:param pulumi.Input[_builtins.str] managed_key_id: The ID of the previously configured managed key. This field is
|
|
1305
1304
|
required if `type` is `kms` and it conflicts with `managed_key_name`
|
|
1306
|
-
:param pulumi.Input[
|
|
1305
|
+
:param pulumi.Input[_builtins.str] managed_key_name: The name of the previously configured managed key. This field is
|
|
1307
1306
|
required if `type` is `kms` and it conflicts with `managed_key_id`
|
|
1308
|
-
:param pulumi.Input[
|
|
1307
|
+
:param pulumi.Input[_builtins.str] namespace: The namespace to provision the resource in.
|
|
1309
1308
|
The value should not contain leading or trailing forward slashes.
|
|
1310
1309
|
The `namespace` is always relative to the provider's configured [namespace](https://www.terraform.io/docs/providers/vault/index.html#namespace).
|
|
1311
1310
|
*Available only for Vault Enterprise*.
|
|
1312
|
-
:param pulumi.Input[
|
|
1313
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
1314
|
-
:param pulumi.Input[
|
|
1315
|
-
:param pulumi.Input[
|
|
1316
|
-
:param pulumi.Input[
|
|
1317
|
-
:param pulumi.Input[
|
|
1318
|
-
:param pulumi.Input[
|
|
1319
|
-
:param pulumi.Input[
|
|
1320
|
-
:param pulumi.Input[
|
|
1321
|
-
:param pulumi.Input[
|
|
1322
|
-
:param pulumi.Input[
|
|
1323
|
-
:param pulumi.Input[
|
|
1311
|
+
:param pulumi.Input[_builtins.str] organization: The organization
|
|
1312
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] other_sans: List of other SANs
|
|
1313
|
+
:param pulumi.Input[_builtins.str] ou: The organization unit
|
|
1314
|
+
:param pulumi.Input[_builtins.str] postal_code: The postal code
|
|
1315
|
+
:param pulumi.Input[_builtins.str] private_key: The private key
|
|
1316
|
+
:param pulumi.Input[_builtins.str] private_key_format: The private key format
|
|
1317
|
+
:param pulumi.Input[_builtins.str] private_key_type: The private key type
|
|
1318
|
+
:param pulumi.Input[_builtins.str] province: The province
|
|
1319
|
+
:param pulumi.Input[_builtins.str] serial_number: The requested Subject's named Serial Number
|
|
1320
|
+
:param pulumi.Input[_builtins.int] signature_bits: The number of bits to use in the signature algorithm
|
|
1321
|
+
:param pulumi.Input[_builtins.str] street_address: The street address
|
|
1322
|
+
:param pulumi.Input[_builtins.str] type: Type of intermediate to create. Must be either \\"exported\\" or \\"internal\\"
|
|
1324
1323
|
or \\"kms\\"
|
|
1325
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
1324
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] uri_sans: List of alternative URIs
|
|
1326
1325
|
"""
|
|
1327
1326
|
opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
|
|
1328
1327
|
|
|
@@ -1362,9 +1361,9 @@ class SecretBackendIntermediateCertRequest(pulumi.CustomResource):
|
|
|
1362
1361
|
__props__.__dict__["uri_sans"] = uri_sans
|
|
1363
1362
|
return SecretBackendIntermediateCertRequest(resource_name, opts=opts, __props__=__props__)
|
|
1364
1363
|
|
|
1365
|
-
@property
|
|
1364
|
+
@_builtins.property
|
|
1366
1365
|
@pulumi.getter(name="addBasicConstraints")
|
|
1367
|
-
def add_basic_constraints(self) -> pulumi.Output[Optional[
|
|
1366
|
+
def add_basic_constraints(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1368
1367
|
"""
|
|
1369
1368
|
Adds a Basic Constraints extension with 'CA: true'.
|
|
1370
1369
|
Only needed as a workaround in some compatibility scenarios with Active Directory
|
|
@@ -1372,149 +1371,149 @@ class SecretBackendIntermediateCertRequest(pulumi.CustomResource):
|
|
|
1372
1371
|
"""
|
|
1373
1372
|
return pulumi.get(self, "add_basic_constraints")
|
|
1374
1373
|
|
|
1375
|
-
@property
|
|
1374
|
+
@_builtins.property
|
|
1376
1375
|
@pulumi.getter(name="altNames")
|
|
1377
|
-
def alt_names(self) -> pulumi.Output[Optional[Sequence[
|
|
1376
|
+
def alt_names(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
1378
1377
|
"""
|
|
1379
1378
|
List of alternative names
|
|
1380
1379
|
"""
|
|
1381
1380
|
return pulumi.get(self, "alt_names")
|
|
1382
1381
|
|
|
1383
|
-
@property
|
|
1382
|
+
@_builtins.property
|
|
1384
1383
|
@pulumi.getter
|
|
1385
|
-
def backend(self) -> pulumi.Output[
|
|
1384
|
+
def backend(self) -> pulumi.Output[_builtins.str]:
|
|
1386
1385
|
"""
|
|
1387
1386
|
The PKI secret backend the resource belongs to.
|
|
1388
1387
|
"""
|
|
1389
1388
|
return pulumi.get(self, "backend")
|
|
1390
1389
|
|
|
1391
|
-
@property
|
|
1390
|
+
@_builtins.property
|
|
1392
1391
|
@pulumi.getter(name="commonName")
|
|
1393
|
-
def common_name(self) -> pulumi.Output[
|
|
1392
|
+
def common_name(self) -> pulumi.Output[_builtins.str]:
|
|
1394
1393
|
"""
|
|
1395
1394
|
CN of intermediate to create
|
|
1396
1395
|
"""
|
|
1397
1396
|
return pulumi.get(self, "common_name")
|
|
1398
1397
|
|
|
1399
|
-
@property
|
|
1398
|
+
@_builtins.property
|
|
1400
1399
|
@pulumi.getter
|
|
1401
|
-
def country(self) -> pulumi.Output[Optional[
|
|
1400
|
+
def country(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1402
1401
|
"""
|
|
1403
1402
|
The country
|
|
1404
1403
|
"""
|
|
1405
1404
|
return pulumi.get(self, "country")
|
|
1406
1405
|
|
|
1407
|
-
@property
|
|
1406
|
+
@_builtins.property
|
|
1408
1407
|
@pulumi.getter
|
|
1409
|
-
def csr(self) -> pulumi.Output[
|
|
1408
|
+
def csr(self) -> pulumi.Output[_builtins.str]:
|
|
1410
1409
|
"""
|
|
1411
1410
|
The CSR
|
|
1412
1411
|
"""
|
|
1413
1412
|
return pulumi.get(self, "csr")
|
|
1414
1413
|
|
|
1415
|
-
@property
|
|
1414
|
+
@_builtins.property
|
|
1416
1415
|
@pulumi.getter(name="excludeCnFromSans")
|
|
1417
|
-
def exclude_cn_from_sans(self) -> pulumi.Output[Optional[
|
|
1416
|
+
def exclude_cn_from_sans(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1418
1417
|
"""
|
|
1419
1418
|
Flag to exclude CN from SANs
|
|
1420
1419
|
"""
|
|
1421
1420
|
return pulumi.get(self, "exclude_cn_from_sans")
|
|
1422
1421
|
|
|
1423
|
-
@property
|
|
1422
|
+
@_builtins.property
|
|
1424
1423
|
@pulumi.getter
|
|
1425
|
-
def format(self) -> pulumi.Output[Optional[
|
|
1424
|
+
def format(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1426
1425
|
"""
|
|
1427
1426
|
The format of data
|
|
1428
1427
|
"""
|
|
1429
1428
|
return pulumi.get(self, "format")
|
|
1430
1429
|
|
|
1431
|
-
@property
|
|
1430
|
+
@_builtins.property
|
|
1432
1431
|
@pulumi.getter(name="ipSans")
|
|
1433
|
-
def ip_sans(self) -> pulumi.Output[Optional[Sequence[
|
|
1432
|
+
def ip_sans(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
1434
1433
|
"""
|
|
1435
1434
|
List of alternative IPs
|
|
1436
1435
|
"""
|
|
1437
1436
|
return pulumi.get(self, "ip_sans")
|
|
1438
1437
|
|
|
1439
|
-
@property
|
|
1438
|
+
@_builtins.property
|
|
1440
1439
|
@pulumi.getter(name="keyBits")
|
|
1441
|
-
def key_bits(self) -> pulumi.Output[Optional[
|
|
1440
|
+
def key_bits(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
1442
1441
|
"""
|
|
1443
1442
|
The number of bits to use
|
|
1444
1443
|
"""
|
|
1445
1444
|
return pulumi.get(self, "key_bits")
|
|
1446
1445
|
|
|
1447
|
-
@property
|
|
1446
|
+
@_builtins.property
|
|
1448
1447
|
@pulumi.getter(name="keyId")
|
|
1449
|
-
def key_id(self) -> pulumi.Output[
|
|
1448
|
+
def key_id(self) -> pulumi.Output[_builtins.str]:
|
|
1450
1449
|
"""
|
|
1451
1450
|
The ID of the generated key.
|
|
1452
1451
|
"""
|
|
1453
1452
|
return pulumi.get(self, "key_id")
|
|
1454
1453
|
|
|
1455
|
-
@property
|
|
1454
|
+
@_builtins.property
|
|
1456
1455
|
@pulumi.getter(name="keyName")
|
|
1457
|
-
def key_name(self) -> pulumi.Output[
|
|
1456
|
+
def key_name(self) -> pulumi.Output[_builtins.str]:
|
|
1458
1457
|
"""
|
|
1459
1458
|
When a new key is created with this request, optionally specifies
|
|
1460
1459
|
the name for this. The global ref `default` may not be used as a name.
|
|
1461
1460
|
"""
|
|
1462
1461
|
return pulumi.get(self, "key_name")
|
|
1463
1462
|
|
|
1464
|
-
@property
|
|
1463
|
+
@_builtins.property
|
|
1465
1464
|
@pulumi.getter(name="keyRef")
|
|
1466
|
-
def key_ref(self) -> pulumi.Output[
|
|
1465
|
+
def key_ref(self) -> pulumi.Output[_builtins.str]:
|
|
1467
1466
|
"""
|
|
1468
1467
|
Specifies the key (either default, by name, or by identifier) to use
|
|
1469
1468
|
for generating this request. Only suitable for `type=existing` requests.
|
|
1470
1469
|
"""
|
|
1471
1470
|
return pulumi.get(self, "key_ref")
|
|
1472
1471
|
|
|
1473
|
-
@property
|
|
1472
|
+
@_builtins.property
|
|
1474
1473
|
@pulumi.getter(name="keyType")
|
|
1475
|
-
def key_type(self) -> pulumi.Output[Optional[
|
|
1474
|
+
def key_type(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1476
1475
|
"""
|
|
1477
1476
|
The desired key type
|
|
1478
1477
|
"""
|
|
1479
1478
|
return pulumi.get(self, "key_type")
|
|
1480
1479
|
|
|
1481
|
-
@property
|
|
1480
|
+
@_builtins.property
|
|
1482
1481
|
@pulumi.getter(name="keyUsages")
|
|
1483
|
-
def key_usages(self) -> pulumi.Output[Optional[Sequence[
|
|
1482
|
+
def key_usages(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
1484
1483
|
"""
|
|
1485
1484
|
Specifies key_usage to encode in the generated certificate.
|
|
1486
1485
|
"""
|
|
1487
1486
|
return pulumi.get(self, "key_usages")
|
|
1488
1487
|
|
|
1489
|
-
@property
|
|
1488
|
+
@_builtins.property
|
|
1490
1489
|
@pulumi.getter
|
|
1491
|
-
def locality(self) -> pulumi.Output[Optional[
|
|
1490
|
+
def locality(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1492
1491
|
"""
|
|
1493
1492
|
The locality
|
|
1494
1493
|
"""
|
|
1495
1494
|
return pulumi.get(self, "locality")
|
|
1496
1495
|
|
|
1497
|
-
@property
|
|
1496
|
+
@_builtins.property
|
|
1498
1497
|
@pulumi.getter(name="managedKeyId")
|
|
1499
|
-
def managed_key_id(self) -> pulumi.Output[Optional[
|
|
1498
|
+
def managed_key_id(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1500
1499
|
"""
|
|
1501
1500
|
The ID of the previously configured managed key. This field is
|
|
1502
1501
|
required if `type` is `kms` and it conflicts with `managed_key_name`
|
|
1503
1502
|
"""
|
|
1504
1503
|
return pulumi.get(self, "managed_key_id")
|
|
1505
1504
|
|
|
1506
|
-
@property
|
|
1505
|
+
@_builtins.property
|
|
1507
1506
|
@pulumi.getter(name="managedKeyName")
|
|
1508
|
-
def managed_key_name(self) -> pulumi.Output[Optional[
|
|
1507
|
+
def managed_key_name(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1509
1508
|
"""
|
|
1510
1509
|
The name of the previously configured managed key. This field is
|
|
1511
1510
|
required if `type` is `kms` and it conflicts with `managed_key_id`
|
|
1512
1511
|
"""
|
|
1513
1512
|
return pulumi.get(self, "managed_key_name")
|
|
1514
1513
|
|
|
1515
|
-
@property
|
|
1514
|
+
@_builtins.property
|
|
1516
1515
|
@pulumi.getter
|
|
1517
|
-
def namespace(self) -> pulumi.Output[Optional[
|
|
1516
|
+
def namespace(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1518
1517
|
"""
|
|
1519
1518
|
The namespace to provision the resource in.
|
|
1520
1519
|
The value should not contain leading or trailing forward slashes.
|
|
@@ -1523,106 +1522,106 @@ class SecretBackendIntermediateCertRequest(pulumi.CustomResource):
|
|
|
1523
1522
|
"""
|
|
1524
1523
|
return pulumi.get(self, "namespace")
|
|
1525
1524
|
|
|
1526
|
-
@property
|
|
1525
|
+
@_builtins.property
|
|
1527
1526
|
@pulumi.getter
|
|
1528
|
-
def organization(self) -> pulumi.Output[Optional[
|
|
1527
|
+
def organization(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1529
1528
|
"""
|
|
1530
1529
|
The organization
|
|
1531
1530
|
"""
|
|
1532
1531
|
return pulumi.get(self, "organization")
|
|
1533
1532
|
|
|
1534
|
-
@property
|
|
1533
|
+
@_builtins.property
|
|
1535
1534
|
@pulumi.getter(name="otherSans")
|
|
1536
|
-
def other_sans(self) -> pulumi.Output[Optional[Sequence[
|
|
1535
|
+
def other_sans(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
1537
1536
|
"""
|
|
1538
1537
|
List of other SANs
|
|
1539
1538
|
"""
|
|
1540
1539
|
return pulumi.get(self, "other_sans")
|
|
1541
1540
|
|
|
1542
|
-
@property
|
|
1541
|
+
@_builtins.property
|
|
1543
1542
|
@pulumi.getter
|
|
1544
|
-
def ou(self) -> pulumi.Output[Optional[
|
|
1543
|
+
def ou(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1545
1544
|
"""
|
|
1546
1545
|
The organization unit
|
|
1547
1546
|
"""
|
|
1548
1547
|
return pulumi.get(self, "ou")
|
|
1549
1548
|
|
|
1550
|
-
@property
|
|
1549
|
+
@_builtins.property
|
|
1551
1550
|
@pulumi.getter(name="postalCode")
|
|
1552
|
-
def postal_code(self) -> pulumi.Output[Optional[
|
|
1551
|
+
def postal_code(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1553
1552
|
"""
|
|
1554
1553
|
The postal code
|
|
1555
1554
|
"""
|
|
1556
1555
|
return pulumi.get(self, "postal_code")
|
|
1557
1556
|
|
|
1558
|
-
@property
|
|
1557
|
+
@_builtins.property
|
|
1559
1558
|
@pulumi.getter(name="privateKey")
|
|
1560
|
-
def private_key(self) -> pulumi.Output[
|
|
1559
|
+
def private_key(self) -> pulumi.Output[_builtins.str]:
|
|
1561
1560
|
"""
|
|
1562
1561
|
The private key
|
|
1563
1562
|
"""
|
|
1564
1563
|
return pulumi.get(self, "private_key")
|
|
1565
1564
|
|
|
1566
|
-
@property
|
|
1565
|
+
@_builtins.property
|
|
1567
1566
|
@pulumi.getter(name="privateKeyFormat")
|
|
1568
|
-
def private_key_format(self) -> pulumi.Output[Optional[
|
|
1567
|
+
def private_key_format(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1569
1568
|
"""
|
|
1570
1569
|
The private key format
|
|
1571
1570
|
"""
|
|
1572
1571
|
return pulumi.get(self, "private_key_format")
|
|
1573
1572
|
|
|
1574
|
-
@property
|
|
1573
|
+
@_builtins.property
|
|
1575
1574
|
@pulumi.getter(name="privateKeyType")
|
|
1576
|
-
def private_key_type(self) -> pulumi.Output[
|
|
1575
|
+
def private_key_type(self) -> pulumi.Output[_builtins.str]:
|
|
1577
1576
|
"""
|
|
1578
1577
|
The private key type
|
|
1579
1578
|
"""
|
|
1580
1579
|
return pulumi.get(self, "private_key_type")
|
|
1581
1580
|
|
|
1582
|
-
@property
|
|
1581
|
+
@_builtins.property
|
|
1583
1582
|
@pulumi.getter
|
|
1584
|
-
def province(self) -> pulumi.Output[Optional[
|
|
1583
|
+
def province(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1585
1584
|
"""
|
|
1586
1585
|
The province
|
|
1587
1586
|
"""
|
|
1588
1587
|
return pulumi.get(self, "province")
|
|
1589
1588
|
|
|
1590
|
-
@property
|
|
1589
|
+
@_builtins.property
|
|
1591
1590
|
@pulumi.getter(name="serialNumber")
|
|
1592
|
-
def serial_number(self) -> pulumi.Output[Optional[
|
|
1591
|
+
def serial_number(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1593
1592
|
"""
|
|
1594
1593
|
The requested Subject's named Serial Number
|
|
1595
1594
|
"""
|
|
1596
1595
|
return pulumi.get(self, "serial_number")
|
|
1597
1596
|
|
|
1598
|
-
@property
|
|
1597
|
+
@_builtins.property
|
|
1599
1598
|
@pulumi.getter(name="signatureBits")
|
|
1600
|
-
def signature_bits(self) -> pulumi.Output[Optional[
|
|
1599
|
+
def signature_bits(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
1601
1600
|
"""
|
|
1602
1601
|
The number of bits to use in the signature algorithm
|
|
1603
1602
|
"""
|
|
1604
1603
|
return pulumi.get(self, "signature_bits")
|
|
1605
1604
|
|
|
1606
|
-
@property
|
|
1605
|
+
@_builtins.property
|
|
1607
1606
|
@pulumi.getter(name="streetAddress")
|
|
1608
|
-
def street_address(self) -> pulumi.Output[Optional[
|
|
1607
|
+
def street_address(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1609
1608
|
"""
|
|
1610
1609
|
The street address
|
|
1611
1610
|
"""
|
|
1612
1611
|
return pulumi.get(self, "street_address")
|
|
1613
1612
|
|
|
1614
|
-
@property
|
|
1613
|
+
@_builtins.property
|
|
1615
1614
|
@pulumi.getter
|
|
1616
|
-
def type(self) -> pulumi.Output[
|
|
1615
|
+
def type(self) -> pulumi.Output[_builtins.str]:
|
|
1617
1616
|
"""
|
|
1618
1617
|
Type of intermediate to create. Must be either \\"exported\\" or \\"internal\\"
|
|
1619
1618
|
or \\"kms\\"
|
|
1620
1619
|
"""
|
|
1621
1620
|
return pulumi.get(self, "type")
|
|
1622
1621
|
|
|
1623
|
-
@property
|
|
1622
|
+
@_builtins.property
|
|
1624
1623
|
@pulumi.getter(name="uriSans")
|
|
1625
|
-
def uri_sans(self) -> pulumi.Output[Optional[Sequence[
|
|
1624
|
+
def uri_sans(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
1626
1625
|
"""
|
|
1627
1626
|
List of alternative URIs
|
|
1628
1627
|
"""
|