pulumi-vault 6.6.0a1741415971__py3-none-any.whl → 6.7.0__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- pulumi_vault/__init__.py +9 -0
- pulumi_vault/_inputs.py +583 -562
- pulumi_vault/ad/__init__.py +1 -0
- pulumi_vault/ad/get_access_credentials.py +20 -19
- pulumi_vault/ad/secret_backend.py +477 -476
- pulumi_vault/ad/secret_library.py +99 -98
- pulumi_vault/ad/secret_role.py +85 -84
- pulumi_vault/alicloud/__init__.py +1 -0
- pulumi_vault/alicloud/auth_backend_role.py +183 -182
- pulumi_vault/approle/__init__.py +1 -0
- pulumi_vault/approle/auth_backend_login.py +106 -105
- pulumi_vault/approle/auth_backend_role.py +239 -238
- pulumi_vault/approle/auth_backend_role_secret_id.py +162 -161
- pulumi_vault/approle/get_auth_backend_role_id.py +18 -17
- pulumi_vault/audit.py +85 -84
- pulumi_vault/audit_request_header.py +43 -42
- pulumi_vault/auth_backend.py +106 -105
- pulumi_vault/aws/__init__.py +1 -0
- pulumi_vault/aws/auth_backend_cert.py +71 -70
- pulumi_vault/aws/auth_backend_client.py +425 -200
- pulumi_vault/aws/auth_backend_config_identity.py +85 -84
- pulumi_vault/aws/auth_backend_identity_whitelist.py +57 -56
- pulumi_vault/aws/auth_backend_login.py +209 -208
- pulumi_vault/aws/auth_backend_role.py +400 -399
- pulumi_vault/aws/auth_backend_role_tag.py +127 -126
- pulumi_vault/aws/auth_backend_roletag_blacklist.py +57 -56
- pulumi_vault/aws/auth_backend_sts_role.py +71 -70
- pulumi_vault/aws/get_access_credentials.py +44 -43
- pulumi_vault/aws/get_static_access_credentials.py +13 -12
- pulumi_vault/aws/secret_backend.py +523 -306
- pulumi_vault/aws/secret_backend_role.py +211 -210
- pulumi_vault/aws/secret_backend_static_role.py +288 -70
- pulumi_vault/azure/__init__.py +1 -0
- pulumi_vault/azure/_inputs.py +21 -20
- pulumi_vault/azure/auth_backend_config.py +383 -130
- pulumi_vault/azure/auth_backend_role.py +253 -252
- pulumi_vault/azure/backend.py +432 -186
- pulumi_vault/azure/backend_role.py +188 -140
- pulumi_vault/azure/get_access_credentials.py +58 -57
- pulumi_vault/azure/outputs.py +11 -10
- pulumi_vault/cert_auth_backend_role.py +365 -364
- pulumi_vault/config/__init__.py +1 -0
- pulumi_vault/config/__init__.pyi +1 -0
- pulumi_vault/config/_inputs.py +11 -10
- pulumi_vault/config/outputs.py +287 -286
- pulumi_vault/config/ui_custom_message.py +113 -112
- pulumi_vault/config/vars.py +1 -0
- pulumi_vault/consul/__init__.py +1 -0
- pulumi_vault/consul/secret_backend.py +197 -196
- pulumi_vault/consul/secret_backend_role.py +183 -182
- pulumi_vault/database/__init__.py +1 -0
- pulumi_vault/database/_inputs.py +3857 -2200
- pulumi_vault/database/outputs.py +2483 -1330
- pulumi_vault/database/secret_backend_connection.py +333 -112
- pulumi_vault/database/secret_backend_role.py +169 -168
- pulumi_vault/database/secret_backend_static_role.py +283 -140
- pulumi_vault/database/secrets_mount.py +275 -266
- pulumi_vault/egp_policy.py +71 -70
- pulumi_vault/gcp/__init__.py +1 -0
- pulumi_vault/gcp/_inputs.py +82 -81
- pulumi_vault/gcp/auth_backend.py +426 -205
- pulumi_vault/gcp/auth_backend_role.py +281 -280
- pulumi_vault/gcp/get_auth_backend_role.py +70 -69
- pulumi_vault/gcp/outputs.py +50 -49
- pulumi_vault/gcp/secret_backend.py +420 -179
- pulumi_vault/gcp/secret_impersonated_account.py +92 -91
- pulumi_vault/gcp/secret_roleset.py +92 -91
- pulumi_vault/gcp/secret_static_account.py +92 -91
- pulumi_vault/generic/__init__.py +1 -0
- pulumi_vault/generic/endpoint.py +113 -112
- pulumi_vault/generic/get_secret.py +28 -27
- pulumi_vault/generic/secret.py +78 -77
- pulumi_vault/get_auth_backend.py +19 -18
- pulumi_vault/get_auth_backends.py +14 -13
- pulumi_vault/get_namespace.py +15 -14
- pulumi_vault/get_namespaces.py +68 -18
- pulumi_vault/get_nomad_access_token.py +19 -18
- pulumi_vault/get_policy_document.py +6 -5
- pulumi_vault/get_raft_autopilot_state.py +18 -17
- pulumi_vault/github/__init__.py +1 -0
- pulumi_vault/github/_inputs.py +42 -41
- pulumi_vault/github/auth_backend.py +232 -231
- pulumi_vault/github/outputs.py +26 -25
- pulumi_vault/github/team.py +57 -56
- pulumi_vault/github/user.py +57 -56
- pulumi_vault/identity/__init__.py +1 -0
- pulumi_vault/identity/entity.py +85 -84
- pulumi_vault/identity/entity_alias.py +71 -70
- pulumi_vault/identity/entity_policies.py +64 -63
- pulumi_vault/identity/get_entity.py +43 -42
- pulumi_vault/identity/get_group.py +50 -49
- pulumi_vault/identity/get_oidc_client_creds.py +14 -13
- pulumi_vault/identity/get_oidc_openid_config.py +24 -23
- pulumi_vault/identity/get_oidc_public_keys.py +13 -12
- pulumi_vault/identity/group.py +141 -140
- pulumi_vault/identity/group_alias.py +57 -56
- pulumi_vault/identity/group_member_entity_ids.py +57 -56
- pulumi_vault/identity/group_member_group_ids.py +57 -56
- pulumi_vault/identity/group_policies.py +64 -63
- pulumi_vault/identity/mfa_duo.py +148 -147
- pulumi_vault/identity/mfa_login_enforcement.py +120 -119
- pulumi_vault/identity/mfa_okta.py +134 -133
- pulumi_vault/identity/mfa_pingid.py +127 -126
- pulumi_vault/identity/mfa_totp.py +176 -175
- pulumi_vault/identity/oidc.py +29 -28
- pulumi_vault/identity/oidc_assignment.py +57 -56
- pulumi_vault/identity/oidc_client.py +127 -126
- pulumi_vault/identity/oidc_key.py +85 -84
- pulumi_vault/identity/oidc_key_allowed_client_id.py +43 -42
- pulumi_vault/identity/oidc_provider.py +92 -91
- pulumi_vault/identity/oidc_role.py +85 -84
- pulumi_vault/identity/oidc_scope.py +57 -56
- pulumi_vault/identity/outputs.py +32 -31
- pulumi_vault/jwt/__init__.py +1 -0
- pulumi_vault/jwt/_inputs.py +42 -41
- pulumi_vault/jwt/auth_backend.py +288 -287
- pulumi_vault/jwt/auth_backend_role.py +407 -406
- pulumi_vault/jwt/outputs.py +26 -25
- pulumi_vault/kmip/__init__.py +1 -0
- pulumi_vault/kmip/secret_backend.py +183 -182
- pulumi_vault/kmip/secret_role.py +295 -294
- pulumi_vault/kmip/secret_scope.py +57 -56
- pulumi_vault/kubernetes/__init__.py +1 -0
- pulumi_vault/kubernetes/auth_backend_config.py +141 -140
- pulumi_vault/kubernetes/auth_backend_role.py +225 -224
- pulumi_vault/kubernetes/get_auth_backend_config.py +47 -46
- pulumi_vault/kubernetes/get_auth_backend_role.py +70 -69
- pulumi_vault/kubernetes/get_service_account_token.py +38 -37
- pulumi_vault/kubernetes/secret_backend.py +316 -315
- pulumi_vault/kubernetes/secret_backend_role.py +197 -196
- pulumi_vault/kv/__init__.py +1 -0
- pulumi_vault/kv/_inputs.py +21 -20
- pulumi_vault/kv/get_secret.py +17 -16
- pulumi_vault/kv/get_secret_subkeys_v2.py +30 -29
- pulumi_vault/kv/get_secret_v2.py +29 -28
- pulumi_vault/kv/get_secrets_list.py +13 -12
- pulumi_vault/kv/get_secrets_list_v2.py +19 -18
- pulumi_vault/kv/outputs.py +13 -12
- pulumi_vault/kv/secret.py +50 -49
- pulumi_vault/kv/secret_backend_v2.py +71 -70
- pulumi_vault/kv/secret_v2.py +134 -133
- pulumi_vault/ldap/__init__.py +1 -0
- pulumi_vault/ldap/auth_backend.py +754 -533
- pulumi_vault/ldap/auth_backend_group.py +57 -56
- pulumi_vault/ldap/auth_backend_user.py +71 -70
- pulumi_vault/ldap/get_dynamic_credentials.py +17 -16
- pulumi_vault/ldap/get_static_credentials.py +18 -17
- pulumi_vault/ldap/secret_backend.py +720 -499
- pulumi_vault/ldap/secret_backend_dynamic_role.py +127 -126
- pulumi_vault/ldap/secret_backend_library_set.py +99 -98
- pulumi_vault/ldap/secret_backend_static_role.py +99 -98
- pulumi_vault/managed/__init__.py +1 -0
- pulumi_vault/managed/_inputs.py +229 -228
- pulumi_vault/managed/keys.py +15 -14
- pulumi_vault/managed/outputs.py +139 -138
- pulumi_vault/mfa_duo.py +113 -112
- pulumi_vault/mfa_okta.py +113 -112
- pulumi_vault/mfa_pingid.py +120 -119
- pulumi_vault/mfa_totp.py +127 -126
- pulumi_vault/mongodbatlas/__init__.py +1 -0
- pulumi_vault/mongodbatlas/secret_backend.py +64 -63
- pulumi_vault/mongodbatlas/secret_role.py +155 -154
- pulumi_vault/mount.py +274 -273
- pulumi_vault/namespace.py +64 -63
- pulumi_vault/nomad_secret_backend.py +211 -210
- pulumi_vault/nomad_secret_role.py +85 -84
- pulumi_vault/okta/__init__.py +1 -0
- pulumi_vault/okta/_inputs.py +26 -25
- pulumi_vault/okta/auth_backend.py +274 -273
- pulumi_vault/okta/auth_backend_group.py +57 -56
- pulumi_vault/okta/auth_backend_user.py +71 -70
- pulumi_vault/okta/outputs.py +16 -15
- pulumi_vault/outputs.py +73 -60
- pulumi_vault/password_policy.py +43 -42
- pulumi_vault/pkisecret/__init__.py +3 -0
- pulumi_vault/pkisecret/_inputs.py +31 -36
- pulumi_vault/pkisecret/backend_acme_eab.py +92 -91
- pulumi_vault/pkisecret/backend_config_acme.py +174 -126
- pulumi_vault/pkisecret/backend_config_auto_tidy.py +1377 -0
- pulumi_vault/pkisecret/backend_config_cluster.py +57 -56
- pulumi_vault/pkisecret/backend_config_cmpv2.py +152 -104
- pulumi_vault/pkisecret/backend_config_est.py +120 -119
- pulumi_vault/pkisecret/get_backend_cert_metadata.py +278 -0
- pulumi_vault/pkisecret/get_backend_config_cmpv2.py +35 -17
- pulumi_vault/pkisecret/get_backend_config_est.py +19 -18
- pulumi_vault/pkisecret/get_backend_issuer.py +139 -25
- pulumi_vault/pkisecret/get_backend_issuers.py +15 -14
- pulumi_vault/pkisecret/get_backend_key.py +20 -19
- pulumi_vault/pkisecret/get_backend_keys.py +15 -14
- pulumi_vault/pkisecret/outputs.py +28 -31
- pulumi_vault/pkisecret/secret_backend_cert.py +439 -297
- pulumi_vault/pkisecret/secret_backend_config_ca.py +43 -42
- pulumi_vault/pkisecret/secret_backend_config_issuers.py +57 -56
- pulumi_vault/pkisecret/secret_backend_config_urls.py +85 -84
- pulumi_vault/pkisecret/secret_backend_crl_config.py +237 -182
- pulumi_vault/pkisecret/secret_backend_intermediate_cert_request.py +520 -378
- pulumi_vault/pkisecret/secret_backend_intermediate_set_signed.py +57 -56
- pulumi_vault/pkisecret/secret_backend_issuer.py +441 -175
- pulumi_vault/pkisecret/secret_backend_key.py +120 -119
- pulumi_vault/pkisecret/secret_backend_role.py +894 -644
- pulumi_vault/pkisecret/secret_backend_root_cert.py +851 -427
- pulumi_vault/pkisecret/secret_backend_root_sign_intermediate.py +936 -357
- pulumi_vault/pkisecret/secret_backend_sign.py +347 -252
- pulumi_vault/plugin.py +127 -126
- pulumi_vault/plugin_pinned_version.py +43 -42
- pulumi_vault/policy.py +43 -42
- pulumi_vault/provider.py +120 -119
- pulumi_vault/pulumi-plugin.json +1 -1
- pulumi_vault/quota_lease_count.py +85 -84
- pulumi_vault/quota_rate_limit.py +113 -112
- pulumi_vault/rabbitmq/__init__.py +1 -0
- pulumi_vault/rabbitmq/_inputs.py +41 -40
- pulumi_vault/rabbitmq/outputs.py +25 -24
- pulumi_vault/rabbitmq/secret_backend.py +169 -168
- pulumi_vault/rabbitmq/secret_backend_role.py +57 -56
- pulumi_vault/raft_autopilot.py +113 -112
- pulumi_vault/raft_snapshot_agent_config.py +393 -392
- pulumi_vault/rgp_policy.py +57 -56
- pulumi_vault/saml/__init__.py +1 -0
- pulumi_vault/saml/auth_backend.py +155 -154
- pulumi_vault/saml/auth_backend_role.py +239 -238
- pulumi_vault/secrets/__init__.py +1 -0
- pulumi_vault/secrets/_inputs.py +16 -15
- pulumi_vault/secrets/outputs.py +10 -9
- pulumi_vault/secrets/sync_association.py +71 -70
- pulumi_vault/secrets/sync_aws_destination.py +148 -147
- pulumi_vault/secrets/sync_azure_destination.py +148 -147
- pulumi_vault/secrets/sync_config.py +43 -42
- pulumi_vault/secrets/sync_gcp_destination.py +106 -105
- pulumi_vault/secrets/sync_gh_destination.py +134 -133
- pulumi_vault/secrets/sync_github_apps.py +64 -63
- pulumi_vault/secrets/sync_vercel_destination.py +120 -119
- pulumi_vault/ssh/__init__.py +2 -0
- pulumi_vault/ssh/_inputs.py +11 -10
- pulumi_vault/ssh/get_secret_backend_sign.py +295 -0
- pulumi_vault/ssh/outputs.py +7 -6
- pulumi_vault/ssh/secret_backend_ca.py +99 -98
- pulumi_vault/ssh/secret_backend_role.py +365 -364
- pulumi_vault/terraformcloud/__init__.py +1 -0
- pulumi_vault/terraformcloud/secret_backend.py +111 -110
- pulumi_vault/terraformcloud/secret_creds.py +74 -73
- pulumi_vault/terraformcloud/secret_role.py +96 -95
- pulumi_vault/token.py +246 -245
- pulumi_vault/tokenauth/__init__.py +1 -0
- pulumi_vault/tokenauth/auth_backend_role.py +267 -266
- pulumi_vault/transform/__init__.py +1 -0
- pulumi_vault/transform/alphabet.py +57 -56
- pulumi_vault/transform/get_decode.py +47 -46
- pulumi_vault/transform/get_encode.py +47 -46
- pulumi_vault/transform/role.py +57 -56
- pulumi_vault/transform/template.py +113 -112
- pulumi_vault/transform/transformation.py +141 -140
- pulumi_vault/transit/__init__.py +3 -0
- pulumi_vault/transit/get_decrypt.py +18 -17
- pulumi_vault/transit/get_encrypt.py +21 -20
- pulumi_vault/transit/get_sign.py +325 -0
- pulumi_vault/transit/get_verify.py +355 -0
- pulumi_vault/transit/secret_backend_key.py +394 -231
- pulumi_vault/transit/secret_cache_config.py +43 -42
- {pulumi_vault-6.6.0a1741415971.dist-info → pulumi_vault-6.7.0.dist-info}/METADATA +2 -2
- pulumi_vault-6.7.0.dist-info/RECORD +265 -0
- {pulumi_vault-6.6.0a1741415971.dist-info → pulumi_vault-6.7.0.dist-info}/WHEEL +1 -1
- pulumi_vault-6.6.0a1741415971.dist-info/RECORD +0 -260
- {pulumi_vault-6.6.0a1741415971.dist-info → pulumi_vault-6.7.0.dist-info}/top_level.txt +0 -0
|
@@ -2,6 +2,7 @@
|
|
|
2
2
|
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
|
|
3
3
|
# *** Do not edit by hand unless you're certain you know what you are doing! ***
|
|
4
4
|
|
|
5
|
+
import builtins
|
|
5
6
|
import copy
|
|
6
7
|
import warnings
|
|
7
8
|
import sys
|
|
@@ -19,68 +20,74 @@ __all__ = ['SecretBackendIntermediateCertRequestArgs', 'SecretBackendIntermediat
|
|
|
19
20
|
@pulumi.input_type
|
|
20
21
|
class SecretBackendIntermediateCertRequestArgs:
|
|
21
22
|
def __init__(__self__, *,
|
|
22
|
-
backend: pulumi.Input[str],
|
|
23
|
-
common_name: pulumi.Input[str],
|
|
24
|
-
type: pulumi.Input[str],
|
|
25
|
-
add_basic_constraints: Optional[pulumi.Input[bool]] = None,
|
|
26
|
-
alt_names: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
27
|
-
country: Optional[pulumi.Input[str]] = None,
|
|
28
|
-
exclude_cn_from_sans: Optional[pulumi.Input[bool]] = None,
|
|
29
|
-
format: Optional[pulumi.Input[str]] = None,
|
|
30
|
-
ip_sans: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
31
|
-
key_bits: Optional[pulumi.Input[int]] = None,
|
|
32
|
-
key_name: Optional[pulumi.Input[str]] = None,
|
|
33
|
-
key_ref: Optional[pulumi.Input[str]] = None,
|
|
34
|
-
key_type: Optional[pulumi.Input[str]] = None,
|
|
35
|
-
|
|
36
|
-
|
|
37
|
-
|
|
38
|
-
|
|
39
|
-
|
|
40
|
-
|
|
41
|
-
|
|
42
|
-
|
|
43
|
-
|
|
44
|
-
|
|
45
|
-
|
|
46
|
-
|
|
23
|
+
backend: pulumi.Input[builtins.str],
|
|
24
|
+
common_name: pulumi.Input[builtins.str],
|
|
25
|
+
type: pulumi.Input[builtins.str],
|
|
26
|
+
add_basic_constraints: Optional[pulumi.Input[builtins.bool]] = None,
|
|
27
|
+
alt_names: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
28
|
+
country: Optional[pulumi.Input[builtins.str]] = None,
|
|
29
|
+
exclude_cn_from_sans: Optional[pulumi.Input[builtins.bool]] = None,
|
|
30
|
+
format: Optional[pulumi.Input[builtins.str]] = None,
|
|
31
|
+
ip_sans: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
32
|
+
key_bits: Optional[pulumi.Input[builtins.int]] = None,
|
|
33
|
+
key_name: Optional[pulumi.Input[builtins.str]] = None,
|
|
34
|
+
key_ref: Optional[pulumi.Input[builtins.str]] = None,
|
|
35
|
+
key_type: Optional[pulumi.Input[builtins.str]] = None,
|
|
36
|
+
key_usages: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
37
|
+
locality: Optional[pulumi.Input[builtins.str]] = None,
|
|
38
|
+
managed_key_id: Optional[pulumi.Input[builtins.str]] = None,
|
|
39
|
+
managed_key_name: Optional[pulumi.Input[builtins.str]] = None,
|
|
40
|
+
namespace: Optional[pulumi.Input[builtins.str]] = None,
|
|
41
|
+
organization: Optional[pulumi.Input[builtins.str]] = None,
|
|
42
|
+
other_sans: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
43
|
+
ou: Optional[pulumi.Input[builtins.str]] = None,
|
|
44
|
+
postal_code: Optional[pulumi.Input[builtins.str]] = None,
|
|
45
|
+
private_key_format: Optional[pulumi.Input[builtins.str]] = None,
|
|
46
|
+
province: Optional[pulumi.Input[builtins.str]] = None,
|
|
47
|
+
serial_number: Optional[pulumi.Input[builtins.str]] = None,
|
|
48
|
+
signature_bits: Optional[pulumi.Input[builtins.int]] = None,
|
|
49
|
+
street_address: Optional[pulumi.Input[builtins.str]] = None,
|
|
50
|
+
uri_sans: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None):
|
|
47
51
|
"""
|
|
48
52
|
The set of arguments for constructing a SecretBackendIntermediateCertRequest resource.
|
|
49
|
-
:param pulumi.Input[str] backend: The PKI secret backend the resource belongs to.
|
|
50
|
-
:param pulumi.Input[str] common_name: CN of intermediate to create
|
|
51
|
-
:param pulumi.Input[str] type: Type of intermediate to create. Must be either \\"exported\\" or \\"internal\\"
|
|
53
|
+
:param pulumi.Input[builtins.str] backend: The PKI secret backend the resource belongs to.
|
|
54
|
+
:param pulumi.Input[builtins.str] common_name: CN of intermediate to create
|
|
55
|
+
:param pulumi.Input[builtins.str] type: Type of intermediate to create. Must be either \\"exported\\" or \\"internal\\"
|
|
52
56
|
or \\"kms\\"
|
|
53
|
-
:param pulumi.Input[bool] add_basic_constraints: Adds a Basic Constraints extension with 'CA: true'.
|
|
57
|
+
:param pulumi.Input[builtins.bool] add_basic_constraints: Adds a Basic Constraints extension with 'CA: true'.
|
|
54
58
|
Only needed as a workaround in some compatibility scenarios with Active Directory
|
|
55
59
|
Certificate Services
|
|
56
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] alt_names: List of alternative names
|
|
57
|
-
:param pulumi.Input[str] country: The country
|
|
58
|
-
:param pulumi.Input[bool] exclude_cn_from_sans: Flag to exclude CN from SANs
|
|
59
|
-
:param pulumi.Input[str] format: The format of data
|
|
60
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] ip_sans: List of alternative IPs
|
|
61
|
-
:param pulumi.Input[int] key_bits: The number of bits to use
|
|
62
|
-
:param pulumi.Input[str] key_name: When a new key is created with this request, optionally specifies
|
|
60
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] alt_names: List of alternative names
|
|
61
|
+
:param pulumi.Input[builtins.str] country: The country
|
|
62
|
+
:param pulumi.Input[builtins.bool] exclude_cn_from_sans: Flag to exclude CN from SANs
|
|
63
|
+
:param pulumi.Input[builtins.str] format: The format of data
|
|
64
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] ip_sans: List of alternative IPs
|
|
65
|
+
:param pulumi.Input[builtins.int] key_bits: The number of bits to use
|
|
66
|
+
:param pulumi.Input[builtins.str] key_name: When a new key is created with this request, optionally specifies
|
|
63
67
|
the name for this. The global ref `default` may not be used as a name.
|
|
64
|
-
:param pulumi.Input[str] key_ref: Specifies the key (either default, by name, or by identifier) to use
|
|
68
|
+
:param pulumi.Input[builtins.str] key_ref: Specifies the key (either default, by name, or by identifier) to use
|
|
65
69
|
for generating this request. Only suitable for `type=existing` requests.
|
|
66
|
-
:param pulumi.Input[str] key_type: The desired key type
|
|
67
|
-
:param pulumi.Input[str]
|
|
68
|
-
:param pulumi.Input[str]
|
|
70
|
+
:param pulumi.Input[builtins.str] key_type: The desired key type
|
|
71
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] key_usages: Specifies key_usage to encode in the generated certificate.
|
|
72
|
+
:param pulumi.Input[builtins.str] locality: The locality
|
|
73
|
+
:param pulumi.Input[builtins.str] managed_key_id: The ID of the previously configured managed key. This field is
|
|
69
74
|
required if `type` is `kms` and it conflicts with `managed_key_name`
|
|
70
|
-
:param pulumi.Input[str] managed_key_name: The name of the previously configured managed key. This field is
|
|
75
|
+
:param pulumi.Input[builtins.str] managed_key_name: The name of the previously configured managed key. This field is
|
|
71
76
|
required if `type` is `kms` and it conflicts with `managed_key_id`
|
|
72
|
-
:param pulumi.Input[str] namespace: The namespace to provision the resource in.
|
|
77
|
+
:param pulumi.Input[builtins.str] namespace: The namespace to provision the resource in.
|
|
73
78
|
The value should not contain leading or trailing forward slashes.
|
|
74
79
|
The `namespace` is always relative to the provider's configured [namespace](https://www.terraform.io/docs/providers/vault/index.html#namespace).
|
|
75
80
|
*Available only for Vault Enterprise*.
|
|
76
|
-
:param pulumi.Input[str] organization: The organization
|
|
77
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] other_sans: List of other SANs
|
|
78
|
-
:param pulumi.Input[str] ou: The organization unit
|
|
79
|
-
:param pulumi.Input[str] postal_code: The postal code
|
|
80
|
-
:param pulumi.Input[str] private_key_format: The private key format
|
|
81
|
-
:param pulumi.Input[str] province: The province
|
|
82
|
-
:param pulumi.Input[str]
|
|
83
|
-
:param pulumi.Input[
|
|
81
|
+
:param pulumi.Input[builtins.str] organization: The organization
|
|
82
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] other_sans: List of other SANs
|
|
83
|
+
:param pulumi.Input[builtins.str] ou: The organization unit
|
|
84
|
+
:param pulumi.Input[builtins.str] postal_code: The postal code
|
|
85
|
+
:param pulumi.Input[builtins.str] private_key_format: The private key format
|
|
86
|
+
:param pulumi.Input[builtins.str] province: The province
|
|
87
|
+
:param pulumi.Input[builtins.str] serial_number: The requested Subject's named Serial Number
|
|
88
|
+
:param pulumi.Input[builtins.int] signature_bits: The number of bits to use in the signature algorithm
|
|
89
|
+
:param pulumi.Input[builtins.str] street_address: The street address
|
|
90
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] uri_sans: List of alternative URIs
|
|
84
91
|
"""
|
|
85
92
|
pulumi.set(__self__, "backend", backend)
|
|
86
93
|
pulumi.set(__self__, "common_name", common_name)
|
|
@@ -105,6 +112,8 @@ class SecretBackendIntermediateCertRequestArgs:
|
|
|
105
112
|
pulumi.set(__self__, "key_ref", key_ref)
|
|
106
113
|
if key_type is not None:
|
|
107
114
|
pulumi.set(__self__, "key_type", key_type)
|
|
115
|
+
if key_usages is not None:
|
|
116
|
+
pulumi.set(__self__, "key_usages", key_usages)
|
|
108
117
|
if locality is not None:
|
|
109
118
|
pulumi.set(__self__, "locality", locality)
|
|
110
119
|
if managed_key_id is not None:
|
|
@@ -125,6 +134,10 @@ class SecretBackendIntermediateCertRequestArgs:
|
|
|
125
134
|
pulumi.set(__self__, "private_key_format", private_key_format)
|
|
126
135
|
if province is not None:
|
|
127
136
|
pulumi.set(__self__, "province", province)
|
|
137
|
+
if serial_number is not None:
|
|
138
|
+
pulumi.set(__self__, "serial_number", serial_number)
|
|
139
|
+
if signature_bits is not None:
|
|
140
|
+
pulumi.set(__self__, "signature_bits", signature_bits)
|
|
128
141
|
if street_address is not None:
|
|
129
142
|
pulumi.set(__self__, "street_address", street_address)
|
|
130
143
|
if uri_sans is not None:
|
|
@@ -132,31 +145,31 @@ class SecretBackendIntermediateCertRequestArgs:
|
|
|
132
145
|
|
|
133
146
|
@property
|
|
134
147
|
@pulumi.getter
|
|
135
|
-
def backend(self) -> pulumi.Input[str]:
|
|
148
|
+
def backend(self) -> pulumi.Input[builtins.str]:
|
|
136
149
|
"""
|
|
137
150
|
The PKI secret backend the resource belongs to.
|
|
138
151
|
"""
|
|
139
152
|
return pulumi.get(self, "backend")
|
|
140
153
|
|
|
141
154
|
@backend.setter
|
|
142
|
-
def backend(self, value: pulumi.Input[str]):
|
|
155
|
+
def backend(self, value: pulumi.Input[builtins.str]):
|
|
143
156
|
pulumi.set(self, "backend", value)
|
|
144
157
|
|
|
145
158
|
@property
|
|
146
159
|
@pulumi.getter(name="commonName")
|
|
147
|
-
def common_name(self) -> pulumi.Input[str]:
|
|
160
|
+
def common_name(self) -> pulumi.Input[builtins.str]:
|
|
148
161
|
"""
|
|
149
162
|
CN of intermediate to create
|
|
150
163
|
"""
|
|
151
164
|
return pulumi.get(self, "common_name")
|
|
152
165
|
|
|
153
166
|
@common_name.setter
|
|
154
|
-
def common_name(self, value: pulumi.Input[str]):
|
|
167
|
+
def common_name(self, value: pulumi.Input[builtins.str]):
|
|
155
168
|
pulumi.set(self, "common_name", value)
|
|
156
169
|
|
|
157
170
|
@property
|
|
158
171
|
@pulumi.getter
|
|
159
|
-
def type(self) -> pulumi.Input[str]:
|
|
172
|
+
def type(self) -> pulumi.Input[builtins.str]:
|
|
160
173
|
"""
|
|
161
174
|
Type of intermediate to create. Must be either \\"exported\\" or \\"internal\\"
|
|
162
175
|
or \\"kms\\"
|
|
@@ -164,12 +177,12 @@ class SecretBackendIntermediateCertRequestArgs:
|
|
|
164
177
|
return pulumi.get(self, "type")
|
|
165
178
|
|
|
166
179
|
@type.setter
|
|
167
|
-
def type(self, value: pulumi.Input[str]):
|
|
180
|
+
def type(self, value: pulumi.Input[builtins.str]):
|
|
168
181
|
pulumi.set(self, "type", value)
|
|
169
182
|
|
|
170
183
|
@property
|
|
171
184
|
@pulumi.getter(name="addBasicConstraints")
|
|
172
|
-
def add_basic_constraints(self) -> Optional[pulumi.Input[bool]]:
|
|
185
|
+
def add_basic_constraints(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
173
186
|
"""
|
|
174
187
|
Adds a Basic Constraints extension with 'CA: true'.
|
|
175
188
|
Only needed as a workaround in some compatibility scenarios with Active Directory
|
|
@@ -178,84 +191,84 @@ class SecretBackendIntermediateCertRequestArgs:
|
|
|
178
191
|
return pulumi.get(self, "add_basic_constraints")
|
|
179
192
|
|
|
180
193
|
@add_basic_constraints.setter
|
|
181
|
-
def add_basic_constraints(self, value: Optional[pulumi.Input[bool]]):
|
|
194
|
+
def add_basic_constraints(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
182
195
|
pulumi.set(self, "add_basic_constraints", value)
|
|
183
196
|
|
|
184
197
|
@property
|
|
185
198
|
@pulumi.getter(name="altNames")
|
|
186
|
-
def alt_names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
199
|
+
def alt_names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
187
200
|
"""
|
|
188
201
|
List of alternative names
|
|
189
202
|
"""
|
|
190
203
|
return pulumi.get(self, "alt_names")
|
|
191
204
|
|
|
192
205
|
@alt_names.setter
|
|
193
|
-
def alt_names(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
206
|
+
def alt_names(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
194
207
|
pulumi.set(self, "alt_names", value)
|
|
195
208
|
|
|
196
209
|
@property
|
|
197
210
|
@pulumi.getter
|
|
198
|
-
def country(self) -> Optional[pulumi.Input[str]]:
|
|
211
|
+
def country(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
199
212
|
"""
|
|
200
213
|
The country
|
|
201
214
|
"""
|
|
202
215
|
return pulumi.get(self, "country")
|
|
203
216
|
|
|
204
217
|
@country.setter
|
|
205
|
-
def country(self, value: Optional[pulumi.Input[str]]):
|
|
218
|
+
def country(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
206
219
|
pulumi.set(self, "country", value)
|
|
207
220
|
|
|
208
221
|
@property
|
|
209
222
|
@pulumi.getter(name="excludeCnFromSans")
|
|
210
|
-
def exclude_cn_from_sans(self) -> Optional[pulumi.Input[bool]]:
|
|
223
|
+
def exclude_cn_from_sans(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
211
224
|
"""
|
|
212
225
|
Flag to exclude CN from SANs
|
|
213
226
|
"""
|
|
214
227
|
return pulumi.get(self, "exclude_cn_from_sans")
|
|
215
228
|
|
|
216
229
|
@exclude_cn_from_sans.setter
|
|
217
|
-
def exclude_cn_from_sans(self, value: Optional[pulumi.Input[bool]]):
|
|
230
|
+
def exclude_cn_from_sans(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
218
231
|
pulumi.set(self, "exclude_cn_from_sans", value)
|
|
219
232
|
|
|
220
233
|
@property
|
|
221
234
|
@pulumi.getter
|
|
222
|
-
def format(self) -> Optional[pulumi.Input[str]]:
|
|
235
|
+
def format(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
223
236
|
"""
|
|
224
237
|
The format of data
|
|
225
238
|
"""
|
|
226
239
|
return pulumi.get(self, "format")
|
|
227
240
|
|
|
228
241
|
@format.setter
|
|
229
|
-
def format(self, value: Optional[pulumi.Input[str]]):
|
|
242
|
+
def format(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
230
243
|
pulumi.set(self, "format", value)
|
|
231
244
|
|
|
232
245
|
@property
|
|
233
246
|
@pulumi.getter(name="ipSans")
|
|
234
|
-
def ip_sans(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
247
|
+
def ip_sans(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
235
248
|
"""
|
|
236
249
|
List of alternative IPs
|
|
237
250
|
"""
|
|
238
251
|
return pulumi.get(self, "ip_sans")
|
|
239
252
|
|
|
240
253
|
@ip_sans.setter
|
|
241
|
-
def ip_sans(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
254
|
+
def ip_sans(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
242
255
|
pulumi.set(self, "ip_sans", value)
|
|
243
256
|
|
|
244
257
|
@property
|
|
245
258
|
@pulumi.getter(name="keyBits")
|
|
246
|
-
def key_bits(self) -> Optional[pulumi.Input[int]]:
|
|
259
|
+
def key_bits(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
247
260
|
"""
|
|
248
261
|
The number of bits to use
|
|
249
262
|
"""
|
|
250
263
|
return pulumi.get(self, "key_bits")
|
|
251
264
|
|
|
252
265
|
@key_bits.setter
|
|
253
|
-
def key_bits(self, value: Optional[pulumi.Input[int]]):
|
|
266
|
+
def key_bits(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
254
267
|
pulumi.set(self, "key_bits", value)
|
|
255
268
|
|
|
256
269
|
@property
|
|
257
270
|
@pulumi.getter(name="keyName")
|
|
258
|
-
def key_name(self) -> Optional[pulumi.Input[str]]:
|
|
271
|
+
def key_name(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
259
272
|
"""
|
|
260
273
|
When a new key is created with this request, optionally specifies
|
|
261
274
|
the name for this. The global ref `default` may not be used as a name.
|
|
@@ -263,12 +276,12 @@ class SecretBackendIntermediateCertRequestArgs:
|
|
|
263
276
|
return pulumi.get(self, "key_name")
|
|
264
277
|
|
|
265
278
|
@key_name.setter
|
|
266
|
-
def key_name(self, value: Optional[pulumi.Input[str]]):
|
|
279
|
+
def key_name(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
267
280
|
pulumi.set(self, "key_name", value)
|
|
268
281
|
|
|
269
282
|
@property
|
|
270
283
|
@pulumi.getter(name="keyRef")
|
|
271
|
-
def key_ref(self) -> Optional[pulumi.Input[str]]:
|
|
284
|
+
def key_ref(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
272
285
|
"""
|
|
273
286
|
Specifies the key (either default, by name, or by identifier) to use
|
|
274
287
|
for generating this request. Only suitable for `type=existing` requests.
|
|
@@ -276,36 +289,48 @@ class SecretBackendIntermediateCertRequestArgs:
|
|
|
276
289
|
return pulumi.get(self, "key_ref")
|
|
277
290
|
|
|
278
291
|
@key_ref.setter
|
|
279
|
-
def key_ref(self, value: Optional[pulumi.Input[str]]):
|
|
292
|
+
def key_ref(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
280
293
|
pulumi.set(self, "key_ref", value)
|
|
281
294
|
|
|
282
295
|
@property
|
|
283
296
|
@pulumi.getter(name="keyType")
|
|
284
|
-
def key_type(self) -> Optional[pulumi.Input[str]]:
|
|
297
|
+
def key_type(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
285
298
|
"""
|
|
286
299
|
The desired key type
|
|
287
300
|
"""
|
|
288
301
|
return pulumi.get(self, "key_type")
|
|
289
302
|
|
|
290
303
|
@key_type.setter
|
|
291
|
-
def key_type(self, value: Optional[pulumi.Input[str]]):
|
|
304
|
+
def key_type(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
292
305
|
pulumi.set(self, "key_type", value)
|
|
293
306
|
|
|
307
|
+
@property
|
|
308
|
+
@pulumi.getter(name="keyUsages")
|
|
309
|
+
def key_usages(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
310
|
+
"""
|
|
311
|
+
Specifies key_usage to encode in the generated certificate.
|
|
312
|
+
"""
|
|
313
|
+
return pulumi.get(self, "key_usages")
|
|
314
|
+
|
|
315
|
+
@key_usages.setter
|
|
316
|
+
def key_usages(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
317
|
+
pulumi.set(self, "key_usages", value)
|
|
318
|
+
|
|
294
319
|
@property
|
|
295
320
|
@pulumi.getter
|
|
296
|
-
def locality(self) -> Optional[pulumi.Input[str]]:
|
|
321
|
+
def locality(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
297
322
|
"""
|
|
298
323
|
The locality
|
|
299
324
|
"""
|
|
300
325
|
return pulumi.get(self, "locality")
|
|
301
326
|
|
|
302
327
|
@locality.setter
|
|
303
|
-
def locality(self, value: Optional[pulumi.Input[str]]):
|
|
328
|
+
def locality(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
304
329
|
pulumi.set(self, "locality", value)
|
|
305
330
|
|
|
306
331
|
@property
|
|
307
332
|
@pulumi.getter(name="managedKeyId")
|
|
308
|
-
def managed_key_id(self) -> Optional[pulumi.Input[str]]:
|
|
333
|
+
def managed_key_id(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
309
334
|
"""
|
|
310
335
|
The ID of the previously configured managed key. This field is
|
|
311
336
|
required if `type` is `kms` and it conflicts with `managed_key_name`
|
|
@@ -313,12 +338,12 @@ class SecretBackendIntermediateCertRequestArgs:
|
|
|
313
338
|
return pulumi.get(self, "managed_key_id")
|
|
314
339
|
|
|
315
340
|
@managed_key_id.setter
|
|
316
|
-
def managed_key_id(self, value: Optional[pulumi.Input[str]]):
|
|
341
|
+
def managed_key_id(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
317
342
|
pulumi.set(self, "managed_key_id", value)
|
|
318
343
|
|
|
319
344
|
@property
|
|
320
345
|
@pulumi.getter(name="managedKeyName")
|
|
321
|
-
def managed_key_name(self) -> Optional[pulumi.Input[str]]:
|
|
346
|
+
def managed_key_name(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
322
347
|
"""
|
|
323
348
|
The name of the previously configured managed key. This field is
|
|
324
349
|
required if `type` is `kms` and it conflicts with `managed_key_id`
|
|
@@ -326,12 +351,12 @@ class SecretBackendIntermediateCertRequestArgs:
|
|
|
326
351
|
return pulumi.get(self, "managed_key_name")
|
|
327
352
|
|
|
328
353
|
@managed_key_name.setter
|
|
329
|
-
def managed_key_name(self, value: Optional[pulumi.Input[str]]):
|
|
354
|
+
def managed_key_name(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
330
355
|
pulumi.set(self, "managed_key_name", value)
|
|
331
356
|
|
|
332
357
|
@property
|
|
333
358
|
@pulumi.getter
|
|
334
|
-
def namespace(self) -> Optional[pulumi.Input[str]]:
|
|
359
|
+
def namespace(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
335
360
|
"""
|
|
336
361
|
The namespace to provision the resource in.
|
|
337
362
|
The value should not contain leading or trailing forward slashes.
|
|
@@ -341,179 +366,209 @@ class SecretBackendIntermediateCertRequestArgs:
|
|
|
341
366
|
return pulumi.get(self, "namespace")
|
|
342
367
|
|
|
343
368
|
@namespace.setter
|
|
344
|
-
def namespace(self, value: Optional[pulumi.Input[str]]):
|
|
369
|
+
def namespace(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
345
370
|
pulumi.set(self, "namespace", value)
|
|
346
371
|
|
|
347
372
|
@property
|
|
348
373
|
@pulumi.getter
|
|
349
|
-
def organization(self) -> Optional[pulumi.Input[str]]:
|
|
374
|
+
def organization(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
350
375
|
"""
|
|
351
376
|
The organization
|
|
352
377
|
"""
|
|
353
378
|
return pulumi.get(self, "organization")
|
|
354
379
|
|
|
355
380
|
@organization.setter
|
|
356
|
-
def organization(self, value: Optional[pulumi.Input[str]]):
|
|
381
|
+
def organization(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
357
382
|
pulumi.set(self, "organization", value)
|
|
358
383
|
|
|
359
384
|
@property
|
|
360
385
|
@pulumi.getter(name="otherSans")
|
|
361
|
-
def other_sans(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
386
|
+
def other_sans(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
362
387
|
"""
|
|
363
388
|
List of other SANs
|
|
364
389
|
"""
|
|
365
390
|
return pulumi.get(self, "other_sans")
|
|
366
391
|
|
|
367
392
|
@other_sans.setter
|
|
368
|
-
def other_sans(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
393
|
+
def other_sans(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
369
394
|
pulumi.set(self, "other_sans", value)
|
|
370
395
|
|
|
371
396
|
@property
|
|
372
397
|
@pulumi.getter
|
|
373
|
-
def ou(self) -> Optional[pulumi.Input[str]]:
|
|
398
|
+
def ou(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
374
399
|
"""
|
|
375
400
|
The organization unit
|
|
376
401
|
"""
|
|
377
402
|
return pulumi.get(self, "ou")
|
|
378
403
|
|
|
379
404
|
@ou.setter
|
|
380
|
-
def ou(self, value: Optional[pulumi.Input[str]]):
|
|
405
|
+
def ou(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
381
406
|
pulumi.set(self, "ou", value)
|
|
382
407
|
|
|
383
408
|
@property
|
|
384
409
|
@pulumi.getter(name="postalCode")
|
|
385
|
-
def postal_code(self) -> Optional[pulumi.Input[str]]:
|
|
410
|
+
def postal_code(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
386
411
|
"""
|
|
387
412
|
The postal code
|
|
388
413
|
"""
|
|
389
414
|
return pulumi.get(self, "postal_code")
|
|
390
415
|
|
|
391
416
|
@postal_code.setter
|
|
392
|
-
def postal_code(self, value: Optional[pulumi.Input[str]]):
|
|
417
|
+
def postal_code(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
393
418
|
pulumi.set(self, "postal_code", value)
|
|
394
419
|
|
|
395
420
|
@property
|
|
396
421
|
@pulumi.getter(name="privateKeyFormat")
|
|
397
|
-
def private_key_format(self) -> Optional[pulumi.Input[str]]:
|
|
422
|
+
def private_key_format(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
398
423
|
"""
|
|
399
424
|
The private key format
|
|
400
425
|
"""
|
|
401
426
|
return pulumi.get(self, "private_key_format")
|
|
402
427
|
|
|
403
428
|
@private_key_format.setter
|
|
404
|
-
def private_key_format(self, value: Optional[pulumi.Input[str]]):
|
|
429
|
+
def private_key_format(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
405
430
|
pulumi.set(self, "private_key_format", value)
|
|
406
431
|
|
|
407
432
|
@property
|
|
408
433
|
@pulumi.getter
|
|
409
|
-
def province(self) -> Optional[pulumi.Input[str]]:
|
|
434
|
+
def province(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
410
435
|
"""
|
|
411
436
|
The province
|
|
412
437
|
"""
|
|
413
438
|
return pulumi.get(self, "province")
|
|
414
439
|
|
|
415
440
|
@province.setter
|
|
416
|
-
def province(self, value: Optional[pulumi.Input[str]]):
|
|
441
|
+
def province(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
417
442
|
pulumi.set(self, "province", value)
|
|
418
443
|
|
|
444
|
+
@property
|
|
445
|
+
@pulumi.getter(name="serialNumber")
|
|
446
|
+
def serial_number(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
447
|
+
"""
|
|
448
|
+
The requested Subject's named Serial Number
|
|
449
|
+
"""
|
|
450
|
+
return pulumi.get(self, "serial_number")
|
|
451
|
+
|
|
452
|
+
@serial_number.setter
|
|
453
|
+
def serial_number(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
454
|
+
pulumi.set(self, "serial_number", value)
|
|
455
|
+
|
|
456
|
+
@property
|
|
457
|
+
@pulumi.getter(name="signatureBits")
|
|
458
|
+
def signature_bits(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
459
|
+
"""
|
|
460
|
+
The number of bits to use in the signature algorithm
|
|
461
|
+
"""
|
|
462
|
+
return pulumi.get(self, "signature_bits")
|
|
463
|
+
|
|
464
|
+
@signature_bits.setter
|
|
465
|
+
def signature_bits(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
466
|
+
pulumi.set(self, "signature_bits", value)
|
|
467
|
+
|
|
419
468
|
@property
|
|
420
469
|
@pulumi.getter(name="streetAddress")
|
|
421
|
-
def street_address(self) -> Optional[pulumi.Input[str]]:
|
|
470
|
+
def street_address(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
422
471
|
"""
|
|
423
472
|
The street address
|
|
424
473
|
"""
|
|
425
474
|
return pulumi.get(self, "street_address")
|
|
426
475
|
|
|
427
476
|
@street_address.setter
|
|
428
|
-
def street_address(self, value: Optional[pulumi.Input[str]]):
|
|
477
|
+
def street_address(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
429
478
|
pulumi.set(self, "street_address", value)
|
|
430
479
|
|
|
431
480
|
@property
|
|
432
481
|
@pulumi.getter(name="uriSans")
|
|
433
|
-
def uri_sans(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
482
|
+
def uri_sans(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
434
483
|
"""
|
|
435
484
|
List of alternative URIs
|
|
436
485
|
"""
|
|
437
486
|
return pulumi.get(self, "uri_sans")
|
|
438
487
|
|
|
439
488
|
@uri_sans.setter
|
|
440
|
-
def uri_sans(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
489
|
+
def uri_sans(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
441
490
|
pulumi.set(self, "uri_sans", value)
|
|
442
491
|
|
|
443
492
|
|
|
444
493
|
@pulumi.input_type
|
|
445
494
|
class _SecretBackendIntermediateCertRequestState:
|
|
446
495
|
def __init__(__self__, *,
|
|
447
|
-
add_basic_constraints: Optional[pulumi.Input[bool]] = None,
|
|
448
|
-
alt_names: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
449
|
-
backend: Optional[pulumi.Input[str]] = None,
|
|
450
|
-
common_name: Optional[pulumi.Input[str]] = None,
|
|
451
|
-
country: Optional[pulumi.Input[str]] = None,
|
|
452
|
-
csr: Optional[pulumi.Input[str]] = None,
|
|
453
|
-
exclude_cn_from_sans: Optional[pulumi.Input[bool]] = None,
|
|
454
|
-
format: Optional[pulumi.Input[str]] = None,
|
|
455
|
-
ip_sans: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
456
|
-
key_bits: Optional[pulumi.Input[int]] = None,
|
|
457
|
-
key_id: Optional[pulumi.Input[str]] = None,
|
|
458
|
-
key_name: Optional[pulumi.Input[str]] = None,
|
|
459
|
-
key_ref: Optional[pulumi.Input[str]] = None,
|
|
460
|
-
key_type: Optional[pulumi.Input[str]] = None,
|
|
461
|
-
|
|
462
|
-
|
|
463
|
-
|
|
464
|
-
|
|
465
|
-
|
|
466
|
-
|
|
467
|
-
|
|
468
|
-
|
|
469
|
-
|
|
470
|
-
|
|
471
|
-
|
|
472
|
-
|
|
473
|
-
|
|
474
|
-
|
|
475
|
-
|
|
496
|
+
add_basic_constraints: Optional[pulumi.Input[builtins.bool]] = None,
|
|
497
|
+
alt_names: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
498
|
+
backend: Optional[pulumi.Input[builtins.str]] = None,
|
|
499
|
+
common_name: Optional[pulumi.Input[builtins.str]] = None,
|
|
500
|
+
country: Optional[pulumi.Input[builtins.str]] = None,
|
|
501
|
+
csr: Optional[pulumi.Input[builtins.str]] = None,
|
|
502
|
+
exclude_cn_from_sans: Optional[pulumi.Input[builtins.bool]] = None,
|
|
503
|
+
format: Optional[pulumi.Input[builtins.str]] = None,
|
|
504
|
+
ip_sans: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
505
|
+
key_bits: Optional[pulumi.Input[builtins.int]] = None,
|
|
506
|
+
key_id: Optional[pulumi.Input[builtins.str]] = None,
|
|
507
|
+
key_name: Optional[pulumi.Input[builtins.str]] = None,
|
|
508
|
+
key_ref: Optional[pulumi.Input[builtins.str]] = None,
|
|
509
|
+
key_type: Optional[pulumi.Input[builtins.str]] = None,
|
|
510
|
+
key_usages: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
511
|
+
locality: Optional[pulumi.Input[builtins.str]] = None,
|
|
512
|
+
managed_key_id: Optional[pulumi.Input[builtins.str]] = None,
|
|
513
|
+
managed_key_name: Optional[pulumi.Input[builtins.str]] = None,
|
|
514
|
+
namespace: Optional[pulumi.Input[builtins.str]] = None,
|
|
515
|
+
organization: Optional[pulumi.Input[builtins.str]] = None,
|
|
516
|
+
other_sans: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
517
|
+
ou: Optional[pulumi.Input[builtins.str]] = None,
|
|
518
|
+
postal_code: Optional[pulumi.Input[builtins.str]] = None,
|
|
519
|
+
private_key: Optional[pulumi.Input[builtins.str]] = None,
|
|
520
|
+
private_key_format: Optional[pulumi.Input[builtins.str]] = None,
|
|
521
|
+
private_key_type: Optional[pulumi.Input[builtins.str]] = None,
|
|
522
|
+
province: Optional[pulumi.Input[builtins.str]] = None,
|
|
523
|
+
serial_number: Optional[pulumi.Input[builtins.str]] = None,
|
|
524
|
+
signature_bits: Optional[pulumi.Input[builtins.int]] = None,
|
|
525
|
+
street_address: Optional[pulumi.Input[builtins.str]] = None,
|
|
526
|
+
type: Optional[pulumi.Input[builtins.str]] = None,
|
|
527
|
+
uri_sans: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None):
|
|
476
528
|
"""
|
|
477
529
|
Input properties used for looking up and filtering SecretBackendIntermediateCertRequest resources.
|
|
478
|
-
:param pulumi.Input[bool] add_basic_constraints: Adds a Basic Constraints extension with 'CA: true'.
|
|
530
|
+
:param pulumi.Input[builtins.bool] add_basic_constraints: Adds a Basic Constraints extension with 'CA: true'.
|
|
479
531
|
Only needed as a workaround in some compatibility scenarios with Active Directory
|
|
480
532
|
Certificate Services
|
|
481
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] alt_names: List of alternative names
|
|
482
|
-
:param pulumi.Input[str] backend: The PKI secret backend the resource belongs to.
|
|
483
|
-
:param pulumi.Input[str] common_name: CN of intermediate to create
|
|
484
|
-
:param pulumi.Input[str] country: The country
|
|
485
|
-
:param pulumi.Input[str] csr: The CSR
|
|
486
|
-
:param pulumi.Input[bool] exclude_cn_from_sans: Flag to exclude CN from SANs
|
|
487
|
-
:param pulumi.Input[str] format: The format of data
|
|
488
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] ip_sans: List of alternative IPs
|
|
489
|
-
:param pulumi.Input[int] key_bits: The number of bits to use
|
|
490
|
-
:param pulumi.Input[str] key_id: The ID of the generated key.
|
|
491
|
-
:param pulumi.Input[str] key_name: When a new key is created with this request, optionally specifies
|
|
533
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] alt_names: List of alternative names
|
|
534
|
+
:param pulumi.Input[builtins.str] backend: The PKI secret backend the resource belongs to.
|
|
535
|
+
:param pulumi.Input[builtins.str] common_name: CN of intermediate to create
|
|
536
|
+
:param pulumi.Input[builtins.str] country: The country
|
|
537
|
+
:param pulumi.Input[builtins.str] csr: The CSR
|
|
538
|
+
:param pulumi.Input[builtins.bool] exclude_cn_from_sans: Flag to exclude CN from SANs
|
|
539
|
+
:param pulumi.Input[builtins.str] format: The format of data
|
|
540
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] ip_sans: List of alternative IPs
|
|
541
|
+
:param pulumi.Input[builtins.int] key_bits: The number of bits to use
|
|
542
|
+
:param pulumi.Input[builtins.str] key_id: The ID of the generated key.
|
|
543
|
+
:param pulumi.Input[builtins.str] key_name: When a new key is created with this request, optionally specifies
|
|
492
544
|
the name for this. The global ref `default` may not be used as a name.
|
|
493
|
-
:param pulumi.Input[str] key_ref: Specifies the key (either default, by name, or by identifier) to use
|
|
545
|
+
:param pulumi.Input[builtins.str] key_ref: Specifies the key (either default, by name, or by identifier) to use
|
|
494
546
|
for generating this request. Only suitable for `type=existing` requests.
|
|
495
|
-
:param pulumi.Input[str] key_type: The desired key type
|
|
496
|
-
:param pulumi.Input[str]
|
|
497
|
-
:param pulumi.Input[str]
|
|
547
|
+
:param pulumi.Input[builtins.str] key_type: The desired key type
|
|
548
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] key_usages: Specifies key_usage to encode in the generated certificate.
|
|
549
|
+
:param pulumi.Input[builtins.str] locality: The locality
|
|
550
|
+
:param pulumi.Input[builtins.str] managed_key_id: The ID of the previously configured managed key. This field is
|
|
498
551
|
required if `type` is `kms` and it conflicts with `managed_key_name`
|
|
499
|
-
:param pulumi.Input[str] managed_key_name: The name of the previously configured managed key. This field is
|
|
552
|
+
:param pulumi.Input[builtins.str] managed_key_name: The name of the previously configured managed key. This field is
|
|
500
553
|
required if `type` is `kms` and it conflicts with `managed_key_id`
|
|
501
|
-
:param pulumi.Input[str] namespace: The namespace to provision the resource in.
|
|
554
|
+
:param pulumi.Input[builtins.str] namespace: The namespace to provision the resource in.
|
|
502
555
|
The value should not contain leading or trailing forward slashes.
|
|
503
556
|
The `namespace` is always relative to the provider's configured [namespace](https://www.terraform.io/docs/providers/vault/index.html#namespace).
|
|
504
557
|
*Available only for Vault Enterprise*.
|
|
505
|
-
:param pulumi.Input[str] organization: The organization
|
|
506
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] other_sans: List of other SANs
|
|
507
|
-
:param pulumi.Input[str] ou: The organization unit
|
|
508
|
-
:param pulumi.Input[str] postal_code: The postal code
|
|
509
|
-
:param pulumi.Input[str] private_key: The private key
|
|
510
|
-
:param pulumi.Input[str] private_key_format: The private key format
|
|
511
|
-
:param pulumi.Input[str] private_key_type: The private key type
|
|
512
|
-
:param pulumi.Input[str] province: The province
|
|
513
|
-
:param pulumi.Input[str]
|
|
514
|
-
:param pulumi.Input[
|
|
558
|
+
:param pulumi.Input[builtins.str] organization: The organization
|
|
559
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] other_sans: List of other SANs
|
|
560
|
+
:param pulumi.Input[builtins.str] ou: The organization unit
|
|
561
|
+
:param pulumi.Input[builtins.str] postal_code: The postal code
|
|
562
|
+
:param pulumi.Input[builtins.str] private_key: The private key
|
|
563
|
+
:param pulumi.Input[builtins.str] private_key_format: The private key format
|
|
564
|
+
:param pulumi.Input[builtins.str] private_key_type: The private key type
|
|
565
|
+
:param pulumi.Input[builtins.str] province: The province
|
|
566
|
+
:param pulumi.Input[builtins.str] serial_number: The requested Subject's named Serial Number
|
|
567
|
+
:param pulumi.Input[builtins.int] signature_bits: The number of bits to use in the signature algorithm
|
|
568
|
+
:param pulumi.Input[builtins.str] street_address: The street address
|
|
569
|
+
:param pulumi.Input[builtins.str] type: Type of intermediate to create. Must be either \\"exported\\" or \\"internal\\"
|
|
515
570
|
or \\"kms\\"
|
|
516
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] uri_sans: List of alternative URIs
|
|
571
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] uri_sans: List of alternative URIs
|
|
517
572
|
"""
|
|
518
573
|
if add_basic_constraints is not None:
|
|
519
574
|
pulumi.set(__self__, "add_basic_constraints", add_basic_constraints)
|
|
@@ -543,6 +598,8 @@ class _SecretBackendIntermediateCertRequestState:
|
|
|
543
598
|
pulumi.set(__self__, "key_ref", key_ref)
|
|
544
599
|
if key_type is not None:
|
|
545
600
|
pulumi.set(__self__, "key_type", key_type)
|
|
601
|
+
if key_usages is not None:
|
|
602
|
+
pulumi.set(__self__, "key_usages", key_usages)
|
|
546
603
|
if locality is not None:
|
|
547
604
|
pulumi.set(__self__, "locality", locality)
|
|
548
605
|
if managed_key_id is not None:
|
|
@@ -567,6 +624,10 @@ class _SecretBackendIntermediateCertRequestState:
|
|
|
567
624
|
pulumi.set(__self__, "private_key_type", private_key_type)
|
|
568
625
|
if province is not None:
|
|
569
626
|
pulumi.set(__self__, "province", province)
|
|
627
|
+
if serial_number is not None:
|
|
628
|
+
pulumi.set(__self__, "serial_number", serial_number)
|
|
629
|
+
if signature_bits is not None:
|
|
630
|
+
pulumi.set(__self__, "signature_bits", signature_bits)
|
|
570
631
|
if street_address is not None:
|
|
571
632
|
pulumi.set(__self__, "street_address", street_address)
|
|
572
633
|
if type is not None:
|
|
@@ -576,7 +637,7 @@ class _SecretBackendIntermediateCertRequestState:
|
|
|
576
637
|
|
|
577
638
|
@property
|
|
578
639
|
@pulumi.getter(name="addBasicConstraints")
|
|
579
|
-
def add_basic_constraints(self) -> Optional[pulumi.Input[bool]]:
|
|
640
|
+
def add_basic_constraints(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
580
641
|
"""
|
|
581
642
|
Adds a Basic Constraints extension with 'CA: true'.
|
|
582
643
|
Only needed as a workaround in some compatibility scenarios with Active Directory
|
|
@@ -585,132 +646,132 @@ class _SecretBackendIntermediateCertRequestState:
|
|
|
585
646
|
return pulumi.get(self, "add_basic_constraints")
|
|
586
647
|
|
|
587
648
|
@add_basic_constraints.setter
|
|
588
|
-
def add_basic_constraints(self, value: Optional[pulumi.Input[bool]]):
|
|
649
|
+
def add_basic_constraints(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
589
650
|
pulumi.set(self, "add_basic_constraints", value)
|
|
590
651
|
|
|
591
652
|
@property
|
|
592
653
|
@pulumi.getter(name="altNames")
|
|
593
|
-
def alt_names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
654
|
+
def alt_names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
594
655
|
"""
|
|
595
656
|
List of alternative names
|
|
596
657
|
"""
|
|
597
658
|
return pulumi.get(self, "alt_names")
|
|
598
659
|
|
|
599
660
|
@alt_names.setter
|
|
600
|
-
def alt_names(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
661
|
+
def alt_names(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
601
662
|
pulumi.set(self, "alt_names", value)
|
|
602
663
|
|
|
603
664
|
@property
|
|
604
665
|
@pulumi.getter
|
|
605
|
-
def backend(self) -> Optional[pulumi.Input[str]]:
|
|
666
|
+
def backend(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
606
667
|
"""
|
|
607
668
|
The PKI secret backend the resource belongs to.
|
|
608
669
|
"""
|
|
609
670
|
return pulumi.get(self, "backend")
|
|
610
671
|
|
|
611
672
|
@backend.setter
|
|
612
|
-
def backend(self, value: Optional[pulumi.Input[str]]):
|
|
673
|
+
def backend(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
613
674
|
pulumi.set(self, "backend", value)
|
|
614
675
|
|
|
615
676
|
@property
|
|
616
677
|
@pulumi.getter(name="commonName")
|
|
617
|
-
def common_name(self) -> Optional[pulumi.Input[str]]:
|
|
678
|
+
def common_name(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
618
679
|
"""
|
|
619
680
|
CN of intermediate to create
|
|
620
681
|
"""
|
|
621
682
|
return pulumi.get(self, "common_name")
|
|
622
683
|
|
|
623
684
|
@common_name.setter
|
|
624
|
-
def common_name(self, value: Optional[pulumi.Input[str]]):
|
|
685
|
+
def common_name(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
625
686
|
pulumi.set(self, "common_name", value)
|
|
626
687
|
|
|
627
688
|
@property
|
|
628
689
|
@pulumi.getter
|
|
629
|
-
def country(self) -> Optional[pulumi.Input[str]]:
|
|
690
|
+
def country(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
630
691
|
"""
|
|
631
692
|
The country
|
|
632
693
|
"""
|
|
633
694
|
return pulumi.get(self, "country")
|
|
634
695
|
|
|
635
696
|
@country.setter
|
|
636
|
-
def country(self, value: Optional[pulumi.Input[str]]):
|
|
697
|
+
def country(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
637
698
|
pulumi.set(self, "country", value)
|
|
638
699
|
|
|
639
700
|
@property
|
|
640
701
|
@pulumi.getter
|
|
641
|
-
def csr(self) -> Optional[pulumi.Input[str]]:
|
|
702
|
+
def csr(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
642
703
|
"""
|
|
643
704
|
The CSR
|
|
644
705
|
"""
|
|
645
706
|
return pulumi.get(self, "csr")
|
|
646
707
|
|
|
647
708
|
@csr.setter
|
|
648
|
-
def csr(self, value: Optional[pulumi.Input[str]]):
|
|
709
|
+
def csr(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
649
710
|
pulumi.set(self, "csr", value)
|
|
650
711
|
|
|
651
712
|
@property
|
|
652
713
|
@pulumi.getter(name="excludeCnFromSans")
|
|
653
|
-
def exclude_cn_from_sans(self) -> Optional[pulumi.Input[bool]]:
|
|
714
|
+
def exclude_cn_from_sans(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
654
715
|
"""
|
|
655
716
|
Flag to exclude CN from SANs
|
|
656
717
|
"""
|
|
657
718
|
return pulumi.get(self, "exclude_cn_from_sans")
|
|
658
719
|
|
|
659
720
|
@exclude_cn_from_sans.setter
|
|
660
|
-
def exclude_cn_from_sans(self, value: Optional[pulumi.Input[bool]]):
|
|
721
|
+
def exclude_cn_from_sans(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
661
722
|
pulumi.set(self, "exclude_cn_from_sans", value)
|
|
662
723
|
|
|
663
724
|
@property
|
|
664
725
|
@pulumi.getter
|
|
665
|
-
def format(self) -> Optional[pulumi.Input[str]]:
|
|
726
|
+
def format(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
666
727
|
"""
|
|
667
728
|
The format of data
|
|
668
729
|
"""
|
|
669
730
|
return pulumi.get(self, "format")
|
|
670
731
|
|
|
671
732
|
@format.setter
|
|
672
|
-
def format(self, value: Optional[pulumi.Input[str]]):
|
|
733
|
+
def format(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
673
734
|
pulumi.set(self, "format", value)
|
|
674
735
|
|
|
675
736
|
@property
|
|
676
737
|
@pulumi.getter(name="ipSans")
|
|
677
|
-
def ip_sans(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
738
|
+
def ip_sans(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
678
739
|
"""
|
|
679
740
|
List of alternative IPs
|
|
680
741
|
"""
|
|
681
742
|
return pulumi.get(self, "ip_sans")
|
|
682
743
|
|
|
683
744
|
@ip_sans.setter
|
|
684
|
-
def ip_sans(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
745
|
+
def ip_sans(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
685
746
|
pulumi.set(self, "ip_sans", value)
|
|
686
747
|
|
|
687
748
|
@property
|
|
688
749
|
@pulumi.getter(name="keyBits")
|
|
689
|
-
def key_bits(self) -> Optional[pulumi.Input[int]]:
|
|
750
|
+
def key_bits(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
690
751
|
"""
|
|
691
752
|
The number of bits to use
|
|
692
753
|
"""
|
|
693
754
|
return pulumi.get(self, "key_bits")
|
|
694
755
|
|
|
695
756
|
@key_bits.setter
|
|
696
|
-
def key_bits(self, value: Optional[pulumi.Input[int]]):
|
|
757
|
+
def key_bits(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
697
758
|
pulumi.set(self, "key_bits", value)
|
|
698
759
|
|
|
699
760
|
@property
|
|
700
761
|
@pulumi.getter(name="keyId")
|
|
701
|
-
def key_id(self) -> Optional[pulumi.Input[str]]:
|
|
762
|
+
def key_id(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
702
763
|
"""
|
|
703
764
|
The ID of the generated key.
|
|
704
765
|
"""
|
|
705
766
|
return pulumi.get(self, "key_id")
|
|
706
767
|
|
|
707
768
|
@key_id.setter
|
|
708
|
-
def key_id(self, value: Optional[pulumi.Input[str]]):
|
|
769
|
+
def key_id(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
709
770
|
pulumi.set(self, "key_id", value)
|
|
710
771
|
|
|
711
772
|
@property
|
|
712
773
|
@pulumi.getter(name="keyName")
|
|
713
|
-
def key_name(self) -> Optional[pulumi.Input[str]]:
|
|
774
|
+
def key_name(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
714
775
|
"""
|
|
715
776
|
When a new key is created with this request, optionally specifies
|
|
716
777
|
the name for this. The global ref `default` may not be used as a name.
|
|
@@ -718,12 +779,12 @@ class _SecretBackendIntermediateCertRequestState:
|
|
|
718
779
|
return pulumi.get(self, "key_name")
|
|
719
780
|
|
|
720
781
|
@key_name.setter
|
|
721
|
-
def key_name(self, value: Optional[pulumi.Input[str]]):
|
|
782
|
+
def key_name(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
722
783
|
pulumi.set(self, "key_name", value)
|
|
723
784
|
|
|
724
785
|
@property
|
|
725
786
|
@pulumi.getter(name="keyRef")
|
|
726
|
-
def key_ref(self) -> Optional[pulumi.Input[str]]:
|
|
787
|
+
def key_ref(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
727
788
|
"""
|
|
728
789
|
Specifies the key (either default, by name, or by identifier) to use
|
|
729
790
|
for generating this request. Only suitable for `type=existing` requests.
|
|
@@ -731,36 +792,48 @@ class _SecretBackendIntermediateCertRequestState:
|
|
|
731
792
|
return pulumi.get(self, "key_ref")
|
|
732
793
|
|
|
733
794
|
@key_ref.setter
|
|
734
|
-
def key_ref(self, value: Optional[pulumi.Input[str]]):
|
|
795
|
+
def key_ref(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
735
796
|
pulumi.set(self, "key_ref", value)
|
|
736
797
|
|
|
737
798
|
@property
|
|
738
799
|
@pulumi.getter(name="keyType")
|
|
739
|
-
def key_type(self) -> Optional[pulumi.Input[str]]:
|
|
800
|
+
def key_type(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
740
801
|
"""
|
|
741
802
|
The desired key type
|
|
742
803
|
"""
|
|
743
804
|
return pulumi.get(self, "key_type")
|
|
744
805
|
|
|
745
806
|
@key_type.setter
|
|
746
|
-
def key_type(self, value: Optional[pulumi.Input[str]]):
|
|
807
|
+
def key_type(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
747
808
|
pulumi.set(self, "key_type", value)
|
|
748
809
|
|
|
810
|
+
@property
|
|
811
|
+
@pulumi.getter(name="keyUsages")
|
|
812
|
+
def key_usages(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
813
|
+
"""
|
|
814
|
+
Specifies key_usage to encode in the generated certificate.
|
|
815
|
+
"""
|
|
816
|
+
return pulumi.get(self, "key_usages")
|
|
817
|
+
|
|
818
|
+
@key_usages.setter
|
|
819
|
+
def key_usages(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
820
|
+
pulumi.set(self, "key_usages", value)
|
|
821
|
+
|
|
749
822
|
@property
|
|
750
823
|
@pulumi.getter
|
|
751
|
-
def locality(self) -> Optional[pulumi.Input[str]]:
|
|
824
|
+
def locality(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
752
825
|
"""
|
|
753
826
|
The locality
|
|
754
827
|
"""
|
|
755
828
|
return pulumi.get(self, "locality")
|
|
756
829
|
|
|
757
830
|
@locality.setter
|
|
758
|
-
def locality(self, value: Optional[pulumi.Input[str]]):
|
|
831
|
+
def locality(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
759
832
|
pulumi.set(self, "locality", value)
|
|
760
833
|
|
|
761
834
|
@property
|
|
762
835
|
@pulumi.getter(name="managedKeyId")
|
|
763
|
-
def managed_key_id(self) -> Optional[pulumi.Input[str]]:
|
|
836
|
+
def managed_key_id(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
764
837
|
"""
|
|
765
838
|
The ID of the previously configured managed key. This field is
|
|
766
839
|
required if `type` is `kms` and it conflicts with `managed_key_name`
|
|
@@ -768,12 +841,12 @@ class _SecretBackendIntermediateCertRequestState:
|
|
|
768
841
|
return pulumi.get(self, "managed_key_id")
|
|
769
842
|
|
|
770
843
|
@managed_key_id.setter
|
|
771
|
-
def managed_key_id(self, value: Optional[pulumi.Input[str]]):
|
|
844
|
+
def managed_key_id(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
772
845
|
pulumi.set(self, "managed_key_id", value)
|
|
773
846
|
|
|
774
847
|
@property
|
|
775
848
|
@pulumi.getter(name="managedKeyName")
|
|
776
|
-
def managed_key_name(self) -> Optional[pulumi.Input[str]]:
|
|
849
|
+
def managed_key_name(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
777
850
|
"""
|
|
778
851
|
The name of the previously configured managed key. This field is
|
|
779
852
|
required if `type` is `kms` and it conflicts with `managed_key_id`
|
|
@@ -781,12 +854,12 @@ class _SecretBackendIntermediateCertRequestState:
|
|
|
781
854
|
return pulumi.get(self, "managed_key_name")
|
|
782
855
|
|
|
783
856
|
@managed_key_name.setter
|
|
784
|
-
def managed_key_name(self, value: Optional[pulumi.Input[str]]):
|
|
857
|
+
def managed_key_name(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
785
858
|
pulumi.set(self, "managed_key_name", value)
|
|
786
859
|
|
|
787
860
|
@property
|
|
788
861
|
@pulumi.getter
|
|
789
|
-
def namespace(self) -> Optional[pulumi.Input[str]]:
|
|
862
|
+
def namespace(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
790
863
|
"""
|
|
791
864
|
The namespace to provision the resource in.
|
|
792
865
|
The value should not contain leading or trailing forward slashes.
|
|
@@ -796,120 +869,144 @@ class _SecretBackendIntermediateCertRequestState:
|
|
|
796
869
|
return pulumi.get(self, "namespace")
|
|
797
870
|
|
|
798
871
|
@namespace.setter
|
|
799
|
-
def namespace(self, value: Optional[pulumi.Input[str]]):
|
|
872
|
+
def namespace(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
800
873
|
pulumi.set(self, "namespace", value)
|
|
801
874
|
|
|
802
875
|
@property
|
|
803
876
|
@pulumi.getter
|
|
804
|
-
def organization(self) -> Optional[pulumi.Input[str]]:
|
|
877
|
+
def organization(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
805
878
|
"""
|
|
806
879
|
The organization
|
|
807
880
|
"""
|
|
808
881
|
return pulumi.get(self, "organization")
|
|
809
882
|
|
|
810
883
|
@organization.setter
|
|
811
|
-
def organization(self, value: Optional[pulumi.Input[str]]):
|
|
884
|
+
def organization(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
812
885
|
pulumi.set(self, "organization", value)
|
|
813
886
|
|
|
814
887
|
@property
|
|
815
888
|
@pulumi.getter(name="otherSans")
|
|
816
|
-
def other_sans(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
889
|
+
def other_sans(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
817
890
|
"""
|
|
818
891
|
List of other SANs
|
|
819
892
|
"""
|
|
820
893
|
return pulumi.get(self, "other_sans")
|
|
821
894
|
|
|
822
895
|
@other_sans.setter
|
|
823
|
-
def other_sans(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
896
|
+
def other_sans(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
824
897
|
pulumi.set(self, "other_sans", value)
|
|
825
898
|
|
|
826
899
|
@property
|
|
827
900
|
@pulumi.getter
|
|
828
|
-
def ou(self) -> Optional[pulumi.Input[str]]:
|
|
901
|
+
def ou(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
829
902
|
"""
|
|
830
903
|
The organization unit
|
|
831
904
|
"""
|
|
832
905
|
return pulumi.get(self, "ou")
|
|
833
906
|
|
|
834
907
|
@ou.setter
|
|
835
|
-
def ou(self, value: Optional[pulumi.Input[str]]):
|
|
908
|
+
def ou(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
836
909
|
pulumi.set(self, "ou", value)
|
|
837
910
|
|
|
838
911
|
@property
|
|
839
912
|
@pulumi.getter(name="postalCode")
|
|
840
|
-
def postal_code(self) -> Optional[pulumi.Input[str]]:
|
|
913
|
+
def postal_code(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
841
914
|
"""
|
|
842
915
|
The postal code
|
|
843
916
|
"""
|
|
844
917
|
return pulumi.get(self, "postal_code")
|
|
845
918
|
|
|
846
919
|
@postal_code.setter
|
|
847
|
-
def postal_code(self, value: Optional[pulumi.Input[str]]):
|
|
920
|
+
def postal_code(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
848
921
|
pulumi.set(self, "postal_code", value)
|
|
849
922
|
|
|
850
923
|
@property
|
|
851
924
|
@pulumi.getter(name="privateKey")
|
|
852
|
-
def private_key(self) -> Optional[pulumi.Input[str]]:
|
|
925
|
+
def private_key(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
853
926
|
"""
|
|
854
927
|
The private key
|
|
855
928
|
"""
|
|
856
929
|
return pulumi.get(self, "private_key")
|
|
857
930
|
|
|
858
931
|
@private_key.setter
|
|
859
|
-
def private_key(self, value: Optional[pulumi.Input[str]]):
|
|
932
|
+
def private_key(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
860
933
|
pulumi.set(self, "private_key", value)
|
|
861
934
|
|
|
862
935
|
@property
|
|
863
936
|
@pulumi.getter(name="privateKeyFormat")
|
|
864
|
-
def private_key_format(self) -> Optional[pulumi.Input[str]]:
|
|
937
|
+
def private_key_format(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
865
938
|
"""
|
|
866
939
|
The private key format
|
|
867
940
|
"""
|
|
868
941
|
return pulumi.get(self, "private_key_format")
|
|
869
942
|
|
|
870
943
|
@private_key_format.setter
|
|
871
|
-
def private_key_format(self, value: Optional[pulumi.Input[str]]):
|
|
944
|
+
def private_key_format(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
872
945
|
pulumi.set(self, "private_key_format", value)
|
|
873
946
|
|
|
874
947
|
@property
|
|
875
948
|
@pulumi.getter(name="privateKeyType")
|
|
876
|
-
def private_key_type(self) -> Optional[pulumi.Input[str]]:
|
|
949
|
+
def private_key_type(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
877
950
|
"""
|
|
878
951
|
The private key type
|
|
879
952
|
"""
|
|
880
953
|
return pulumi.get(self, "private_key_type")
|
|
881
954
|
|
|
882
955
|
@private_key_type.setter
|
|
883
|
-
def private_key_type(self, value: Optional[pulumi.Input[str]]):
|
|
956
|
+
def private_key_type(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
884
957
|
pulumi.set(self, "private_key_type", value)
|
|
885
958
|
|
|
886
959
|
@property
|
|
887
960
|
@pulumi.getter
|
|
888
|
-
def province(self) -> Optional[pulumi.Input[str]]:
|
|
961
|
+
def province(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
889
962
|
"""
|
|
890
963
|
The province
|
|
891
964
|
"""
|
|
892
965
|
return pulumi.get(self, "province")
|
|
893
966
|
|
|
894
967
|
@province.setter
|
|
895
|
-
def province(self, value: Optional[pulumi.Input[str]]):
|
|
968
|
+
def province(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
896
969
|
pulumi.set(self, "province", value)
|
|
897
970
|
|
|
971
|
+
@property
|
|
972
|
+
@pulumi.getter(name="serialNumber")
|
|
973
|
+
def serial_number(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
974
|
+
"""
|
|
975
|
+
The requested Subject's named Serial Number
|
|
976
|
+
"""
|
|
977
|
+
return pulumi.get(self, "serial_number")
|
|
978
|
+
|
|
979
|
+
@serial_number.setter
|
|
980
|
+
def serial_number(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
981
|
+
pulumi.set(self, "serial_number", value)
|
|
982
|
+
|
|
983
|
+
@property
|
|
984
|
+
@pulumi.getter(name="signatureBits")
|
|
985
|
+
def signature_bits(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
986
|
+
"""
|
|
987
|
+
The number of bits to use in the signature algorithm
|
|
988
|
+
"""
|
|
989
|
+
return pulumi.get(self, "signature_bits")
|
|
990
|
+
|
|
991
|
+
@signature_bits.setter
|
|
992
|
+
def signature_bits(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
993
|
+
pulumi.set(self, "signature_bits", value)
|
|
994
|
+
|
|
898
995
|
@property
|
|
899
996
|
@pulumi.getter(name="streetAddress")
|
|
900
|
-
def street_address(self) -> Optional[pulumi.Input[str]]:
|
|
997
|
+
def street_address(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
901
998
|
"""
|
|
902
999
|
The street address
|
|
903
1000
|
"""
|
|
904
1001
|
return pulumi.get(self, "street_address")
|
|
905
1002
|
|
|
906
1003
|
@street_address.setter
|
|
907
|
-
def street_address(self, value: Optional[pulumi.Input[str]]):
|
|
1004
|
+
def street_address(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
908
1005
|
pulumi.set(self, "street_address", value)
|
|
909
1006
|
|
|
910
1007
|
@property
|
|
911
1008
|
@pulumi.getter
|
|
912
|
-
def type(self) -> Optional[pulumi.Input[str]]:
|
|
1009
|
+
def type(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
913
1010
|
"""
|
|
914
1011
|
Type of intermediate to create. Must be either \\"exported\\" or \\"internal\\"
|
|
915
1012
|
or \\"kms\\"
|
|
@@ -917,19 +1014,19 @@ class _SecretBackendIntermediateCertRequestState:
|
|
|
917
1014
|
return pulumi.get(self, "type")
|
|
918
1015
|
|
|
919
1016
|
@type.setter
|
|
920
|
-
def type(self, value: Optional[pulumi.Input[str]]):
|
|
1017
|
+
def type(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
921
1018
|
pulumi.set(self, "type", value)
|
|
922
1019
|
|
|
923
1020
|
@property
|
|
924
1021
|
@pulumi.getter(name="uriSans")
|
|
925
|
-
def uri_sans(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
1022
|
+
def uri_sans(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
926
1023
|
"""
|
|
927
1024
|
List of alternative URIs
|
|
928
1025
|
"""
|
|
929
1026
|
return pulumi.get(self, "uri_sans")
|
|
930
1027
|
|
|
931
1028
|
@uri_sans.setter
|
|
932
|
-
def uri_sans(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
1029
|
+
def uri_sans(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
933
1030
|
pulumi.set(self, "uri_sans", value)
|
|
934
1031
|
|
|
935
1032
|
|
|
@@ -938,31 +1035,34 @@ class SecretBackendIntermediateCertRequest(pulumi.CustomResource):
|
|
|
938
1035
|
def __init__(__self__,
|
|
939
1036
|
resource_name: str,
|
|
940
1037
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
941
|
-
add_basic_constraints: Optional[pulumi.Input[bool]] = None,
|
|
942
|
-
alt_names: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
943
|
-
backend: Optional[pulumi.Input[str]] = None,
|
|
944
|
-
common_name: Optional[pulumi.Input[str]] = None,
|
|
945
|
-
country: Optional[pulumi.Input[str]] = None,
|
|
946
|
-
exclude_cn_from_sans: Optional[pulumi.Input[bool]] = None,
|
|
947
|
-
format: Optional[pulumi.Input[str]] = None,
|
|
948
|
-
ip_sans: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
949
|
-
key_bits: Optional[pulumi.Input[int]] = None,
|
|
950
|
-
key_name: Optional[pulumi.Input[str]] = None,
|
|
951
|
-
key_ref: Optional[pulumi.Input[str]] = None,
|
|
952
|
-
key_type: Optional[pulumi.Input[str]] = None,
|
|
953
|
-
|
|
954
|
-
|
|
955
|
-
|
|
956
|
-
|
|
957
|
-
|
|
958
|
-
|
|
959
|
-
|
|
960
|
-
|
|
961
|
-
|
|
962
|
-
|
|
963
|
-
|
|
964
|
-
|
|
965
|
-
|
|
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,
|
|
966
1066
|
__props__=None):
|
|
967
1067
|
"""
|
|
968
1068
|
## Example Usage
|
|
@@ -980,41 +1080,44 @@ class SecretBackendIntermediateCertRequest(pulumi.CustomResource):
|
|
|
980
1080
|
|
|
981
1081
|
:param str resource_name: The name of the resource.
|
|
982
1082
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
983
|
-
:param pulumi.Input[bool] add_basic_constraints: Adds a Basic Constraints extension with 'CA: true'.
|
|
1083
|
+
:param pulumi.Input[builtins.bool] add_basic_constraints: Adds a Basic Constraints extension with 'CA: true'.
|
|
984
1084
|
Only needed as a workaround in some compatibility scenarios with Active Directory
|
|
985
1085
|
Certificate Services
|
|
986
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] alt_names: List of alternative names
|
|
987
|
-
:param pulumi.Input[str] backend: The PKI secret backend the resource belongs to.
|
|
988
|
-
:param pulumi.Input[str] common_name: CN of intermediate to create
|
|
989
|
-
:param pulumi.Input[str] country: The country
|
|
990
|
-
:param pulumi.Input[bool] exclude_cn_from_sans: Flag to exclude CN from SANs
|
|
991
|
-
:param pulumi.Input[str] format: The format of data
|
|
992
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] ip_sans: List of alternative IPs
|
|
993
|
-
:param pulumi.Input[int] key_bits: The number of bits to use
|
|
994
|
-
:param pulumi.Input[str] key_name: When a new key is created with this request, optionally specifies
|
|
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
|
|
995
1095
|
the name for this. The global ref `default` may not be used as a name.
|
|
996
|
-
:param pulumi.Input[str] key_ref: Specifies the key (either default, by name, or by identifier) to use
|
|
1096
|
+
:param pulumi.Input[builtins.str] key_ref: Specifies the key (either default, by name, or by identifier) to use
|
|
997
1097
|
for generating this request. Only suitable for `type=existing` requests.
|
|
998
|
-
:param pulumi.Input[str] key_type: The desired key type
|
|
999
|
-
:param pulumi.Input[str]
|
|
1000
|
-
:param pulumi.Input[str]
|
|
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
|
|
1001
1102
|
required if `type` is `kms` and it conflicts with `managed_key_name`
|
|
1002
|
-
:param pulumi.Input[str] managed_key_name: The name of the previously configured managed key. This field is
|
|
1103
|
+
:param pulumi.Input[builtins.str] managed_key_name: The name of the previously configured managed key. This field is
|
|
1003
1104
|
required if `type` is `kms` and it conflicts with `managed_key_id`
|
|
1004
|
-
:param pulumi.Input[str] namespace: The namespace to provision the resource in.
|
|
1105
|
+
:param pulumi.Input[builtins.str] namespace: The namespace to provision the resource in.
|
|
1005
1106
|
The value should not contain leading or trailing forward slashes.
|
|
1006
1107
|
The `namespace` is always relative to the provider's configured [namespace](https://www.terraform.io/docs/providers/vault/index.html#namespace).
|
|
1007
1108
|
*Available only for Vault Enterprise*.
|
|
1008
|
-
:param pulumi.Input[str] organization: The organization
|
|
1009
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] other_sans: List of other SANs
|
|
1010
|
-
:param pulumi.Input[str] ou: The organization unit
|
|
1011
|
-
:param pulumi.Input[str] postal_code: The postal code
|
|
1012
|
-
:param pulumi.Input[str] private_key_format: The private key format
|
|
1013
|
-
:param pulumi.Input[str] province: The province
|
|
1014
|
-
:param pulumi.Input[str]
|
|
1015
|
-
: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\\"
|
|
1016
1119
|
or \\"kms\\"
|
|
1017
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] uri_sans: List of alternative URIs
|
|
1120
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] uri_sans: List of alternative URIs
|
|
1018
1121
|
"""
|
|
1019
1122
|
...
|
|
1020
1123
|
@overload
|
|
@@ -1051,31 +1154,34 @@ class SecretBackendIntermediateCertRequest(pulumi.CustomResource):
|
|
|
1051
1154
|
def _internal_init(__self__,
|
|
1052
1155
|
resource_name: str,
|
|
1053
1156
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
1054
|
-
add_basic_constraints: Optional[pulumi.Input[bool]] = None,
|
|
1055
|
-
alt_names: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1056
|
-
backend: Optional[pulumi.Input[str]] = None,
|
|
1057
|
-
common_name: Optional[pulumi.Input[str]] = None,
|
|
1058
|
-
country: Optional[pulumi.Input[str]] = None,
|
|
1059
|
-
exclude_cn_from_sans: Optional[pulumi.Input[bool]] = None,
|
|
1060
|
-
format: Optional[pulumi.Input[str]] = None,
|
|
1061
|
-
ip_sans: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1062
|
-
key_bits: Optional[pulumi.Input[int]] = None,
|
|
1063
|
-
key_name: Optional[pulumi.Input[str]] = None,
|
|
1064
|
-
key_ref: Optional[pulumi.Input[str]] = None,
|
|
1065
|
-
key_type: Optional[pulumi.Input[str]] = None,
|
|
1066
|
-
|
|
1067
|
-
|
|
1068
|
-
|
|
1069
|
-
|
|
1070
|
-
|
|
1071
|
-
|
|
1072
|
-
|
|
1073
|
-
|
|
1074
|
-
|
|
1075
|
-
|
|
1076
|
-
|
|
1077
|
-
|
|
1078
|
-
|
|
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,
|
|
1079
1185
|
__props__=None):
|
|
1080
1186
|
opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
|
|
1081
1187
|
if not isinstance(opts, pulumi.ResourceOptions):
|
|
@@ -1101,6 +1207,7 @@ class SecretBackendIntermediateCertRequest(pulumi.CustomResource):
|
|
|
1101
1207
|
__props__.__dict__["key_name"] = key_name
|
|
1102
1208
|
__props__.__dict__["key_ref"] = key_ref
|
|
1103
1209
|
__props__.__dict__["key_type"] = key_type
|
|
1210
|
+
__props__.__dict__["key_usages"] = key_usages
|
|
1104
1211
|
__props__.__dict__["locality"] = locality
|
|
1105
1212
|
__props__.__dict__["managed_key_id"] = managed_key_id
|
|
1106
1213
|
__props__.__dict__["managed_key_name"] = managed_key_name
|
|
@@ -1111,6 +1218,8 @@ class SecretBackendIntermediateCertRequest(pulumi.CustomResource):
|
|
|
1111
1218
|
__props__.__dict__["postal_code"] = postal_code
|
|
1112
1219
|
__props__.__dict__["private_key_format"] = private_key_format
|
|
1113
1220
|
__props__.__dict__["province"] = province
|
|
1221
|
+
__props__.__dict__["serial_number"] = serial_number
|
|
1222
|
+
__props__.__dict__["signature_bits"] = signature_bits
|
|
1114
1223
|
__props__.__dict__["street_address"] = street_address
|
|
1115
1224
|
if type is None and not opts.urn:
|
|
1116
1225
|
raise TypeError("Missing required property 'type'")
|
|
@@ -1132,35 +1241,38 @@ class SecretBackendIntermediateCertRequest(pulumi.CustomResource):
|
|
|
1132
1241
|
def get(resource_name: str,
|
|
1133
1242
|
id: pulumi.Input[str],
|
|
1134
1243
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
1135
|
-
add_basic_constraints: Optional[pulumi.Input[bool]] = None,
|
|
1136
|
-
alt_names: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1137
|
-
backend: Optional[pulumi.Input[str]] = None,
|
|
1138
|
-
common_name: Optional[pulumi.Input[str]] = None,
|
|
1139
|
-
country: Optional[pulumi.Input[str]] = None,
|
|
1140
|
-
csr: Optional[pulumi.Input[str]] = None,
|
|
1141
|
-
exclude_cn_from_sans: Optional[pulumi.Input[bool]] = None,
|
|
1142
|
-
format: Optional[pulumi.Input[str]] = None,
|
|
1143
|
-
ip_sans: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1144
|
-
key_bits: Optional[pulumi.Input[int]] = None,
|
|
1145
|
-
key_id: Optional[pulumi.Input[str]] = None,
|
|
1146
|
-
key_name: Optional[pulumi.Input[str]] = None,
|
|
1147
|
-
key_ref: Optional[pulumi.Input[str]] = None,
|
|
1148
|
-
key_type: Optional[pulumi.Input[str]] = None,
|
|
1149
|
-
|
|
1150
|
-
|
|
1151
|
-
|
|
1152
|
-
|
|
1153
|
-
|
|
1154
|
-
|
|
1155
|
-
|
|
1156
|
-
|
|
1157
|
-
|
|
1158
|
-
|
|
1159
|
-
|
|
1160
|
-
|
|
1161
|
-
|
|
1162
|
-
|
|
1163
|
-
|
|
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':
|
|
1164
1276
|
"""
|
|
1165
1277
|
Get an existing SecretBackendIntermediateCertRequest resource's state with the given name, id, and optional extra
|
|
1166
1278
|
properties used to qualify the lookup.
|
|
@@ -1168,45 +1280,48 @@ class SecretBackendIntermediateCertRequest(pulumi.CustomResource):
|
|
|
1168
1280
|
:param str resource_name: The unique name of the resulting resource.
|
|
1169
1281
|
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
|
|
1170
1282
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
1171
|
-
:param pulumi.Input[bool] add_basic_constraints: Adds a Basic Constraints extension with 'CA: true'.
|
|
1283
|
+
:param pulumi.Input[builtins.bool] add_basic_constraints: Adds a Basic Constraints extension with 'CA: true'.
|
|
1172
1284
|
Only needed as a workaround in some compatibility scenarios with Active Directory
|
|
1173
1285
|
Certificate Services
|
|
1174
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] alt_names: List of alternative names
|
|
1175
|
-
:param pulumi.Input[str] backend: The PKI secret backend the resource belongs to.
|
|
1176
|
-
:param pulumi.Input[str] common_name: CN of intermediate to create
|
|
1177
|
-
:param pulumi.Input[str] country: The country
|
|
1178
|
-
:param pulumi.Input[str] csr: The CSR
|
|
1179
|
-
:param pulumi.Input[bool] exclude_cn_from_sans: Flag to exclude CN from SANs
|
|
1180
|
-
:param pulumi.Input[str] format: The format of data
|
|
1181
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] ip_sans: List of alternative IPs
|
|
1182
|
-
:param pulumi.Input[int] key_bits: The number of bits to use
|
|
1183
|
-
:param pulumi.Input[str] key_id: The ID of the generated key.
|
|
1184
|
-
:param pulumi.Input[str] key_name: When a new key is created with this request, optionally specifies
|
|
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
|
|
1185
1297
|
the name for this. The global ref `default` may not be used as a name.
|
|
1186
|
-
:param pulumi.Input[str] key_ref: Specifies the key (either default, by name, or by identifier) to use
|
|
1298
|
+
:param pulumi.Input[builtins.str] key_ref: Specifies the key (either default, by name, or by identifier) to use
|
|
1187
1299
|
for generating this request. Only suitable for `type=existing` requests.
|
|
1188
|
-
:param pulumi.Input[str] key_type: The desired key type
|
|
1189
|
-
:param pulumi.Input[str]
|
|
1190
|
-
:param pulumi.Input[str]
|
|
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
|
|
1191
1304
|
required if `type` is `kms` and it conflicts with `managed_key_name`
|
|
1192
|
-
:param pulumi.Input[str] managed_key_name: The name of the previously configured managed key. This field is
|
|
1305
|
+
:param pulumi.Input[builtins.str] managed_key_name: The name of the previously configured managed key. This field is
|
|
1193
1306
|
required if `type` is `kms` and it conflicts with `managed_key_id`
|
|
1194
|
-
:param pulumi.Input[str] namespace: The namespace to provision the resource in.
|
|
1307
|
+
:param pulumi.Input[builtins.str] namespace: The namespace to provision the resource in.
|
|
1195
1308
|
The value should not contain leading or trailing forward slashes.
|
|
1196
1309
|
The `namespace` is always relative to the provider's configured [namespace](https://www.terraform.io/docs/providers/vault/index.html#namespace).
|
|
1197
1310
|
*Available only for Vault Enterprise*.
|
|
1198
|
-
:param pulumi.Input[str] organization: The organization
|
|
1199
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] other_sans: List of other SANs
|
|
1200
|
-
:param pulumi.Input[str] ou: The organization unit
|
|
1201
|
-
:param pulumi.Input[str] postal_code: The postal code
|
|
1202
|
-
:param pulumi.Input[str] private_key: The private key
|
|
1203
|
-
:param pulumi.Input[str] private_key_format: The private key format
|
|
1204
|
-
:param pulumi.Input[str] private_key_type: The private key type
|
|
1205
|
-
:param pulumi.Input[str] province: The province
|
|
1206
|
-
:param pulumi.Input[str]
|
|
1207
|
-
: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\\"
|
|
1208
1323
|
or \\"kms\\"
|
|
1209
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] uri_sans: List of alternative URIs
|
|
1324
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] uri_sans: List of alternative URIs
|
|
1210
1325
|
"""
|
|
1211
1326
|
opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
|
|
1212
1327
|
|
|
@@ -1226,6 +1341,7 @@ class SecretBackendIntermediateCertRequest(pulumi.CustomResource):
|
|
|
1226
1341
|
__props__.__dict__["key_name"] = key_name
|
|
1227
1342
|
__props__.__dict__["key_ref"] = key_ref
|
|
1228
1343
|
__props__.__dict__["key_type"] = key_type
|
|
1344
|
+
__props__.__dict__["key_usages"] = key_usages
|
|
1229
1345
|
__props__.__dict__["locality"] = locality
|
|
1230
1346
|
__props__.__dict__["managed_key_id"] = managed_key_id
|
|
1231
1347
|
__props__.__dict__["managed_key_name"] = managed_key_name
|
|
@@ -1238,6 +1354,8 @@ class SecretBackendIntermediateCertRequest(pulumi.CustomResource):
|
|
|
1238
1354
|
__props__.__dict__["private_key_format"] = private_key_format
|
|
1239
1355
|
__props__.__dict__["private_key_type"] = private_key_type
|
|
1240
1356
|
__props__.__dict__["province"] = province
|
|
1357
|
+
__props__.__dict__["serial_number"] = serial_number
|
|
1358
|
+
__props__.__dict__["signature_bits"] = signature_bits
|
|
1241
1359
|
__props__.__dict__["street_address"] = street_address
|
|
1242
1360
|
__props__.__dict__["type"] = type
|
|
1243
1361
|
__props__.__dict__["uri_sans"] = uri_sans
|
|
@@ -1245,7 +1363,7 @@ class SecretBackendIntermediateCertRequest(pulumi.CustomResource):
|
|
|
1245
1363
|
|
|
1246
1364
|
@property
|
|
1247
1365
|
@pulumi.getter(name="addBasicConstraints")
|
|
1248
|
-
def add_basic_constraints(self) -> pulumi.Output[Optional[bool]]:
|
|
1366
|
+
def add_basic_constraints(self) -> pulumi.Output[Optional[builtins.bool]]:
|
|
1249
1367
|
"""
|
|
1250
1368
|
Adds a Basic Constraints extension with 'CA: true'.
|
|
1251
1369
|
Only needed as a workaround in some compatibility scenarios with Active Directory
|
|
@@ -1255,7 +1373,7 @@ class SecretBackendIntermediateCertRequest(pulumi.CustomResource):
|
|
|
1255
1373
|
|
|
1256
1374
|
@property
|
|
1257
1375
|
@pulumi.getter(name="altNames")
|
|
1258
|
-
def alt_names(self) -> pulumi.Output[Optional[Sequence[str]]]:
|
|
1376
|
+
def alt_names(self) -> pulumi.Output[Optional[Sequence[builtins.str]]]:
|
|
1259
1377
|
"""
|
|
1260
1378
|
List of alternative names
|
|
1261
1379
|
"""
|
|
@@ -1263,7 +1381,7 @@ class SecretBackendIntermediateCertRequest(pulumi.CustomResource):
|
|
|
1263
1381
|
|
|
1264
1382
|
@property
|
|
1265
1383
|
@pulumi.getter
|
|
1266
|
-
def backend(self) -> pulumi.Output[str]:
|
|
1384
|
+
def backend(self) -> pulumi.Output[builtins.str]:
|
|
1267
1385
|
"""
|
|
1268
1386
|
The PKI secret backend the resource belongs to.
|
|
1269
1387
|
"""
|
|
@@ -1271,7 +1389,7 @@ class SecretBackendIntermediateCertRequest(pulumi.CustomResource):
|
|
|
1271
1389
|
|
|
1272
1390
|
@property
|
|
1273
1391
|
@pulumi.getter(name="commonName")
|
|
1274
|
-
def common_name(self) -> pulumi.Output[str]:
|
|
1392
|
+
def common_name(self) -> pulumi.Output[builtins.str]:
|
|
1275
1393
|
"""
|
|
1276
1394
|
CN of intermediate to create
|
|
1277
1395
|
"""
|
|
@@ -1279,7 +1397,7 @@ class SecretBackendIntermediateCertRequest(pulumi.CustomResource):
|
|
|
1279
1397
|
|
|
1280
1398
|
@property
|
|
1281
1399
|
@pulumi.getter
|
|
1282
|
-
def country(self) -> pulumi.Output[Optional[str]]:
|
|
1400
|
+
def country(self) -> pulumi.Output[Optional[builtins.str]]:
|
|
1283
1401
|
"""
|
|
1284
1402
|
The country
|
|
1285
1403
|
"""
|
|
@@ -1287,7 +1405,7 @@ class SecretBackendIntermediateCertRequest(pulumi.CustomResource):
|
|
|
1287
1405
|
|
|
1288
1406
|
@property
|
|
1289
1407
|
@pulumi.getter
|
|
1290
|
-
def csr(self) -> pulumi.Output[str]:
|
|
1408
|
+
def csr(self) -> pulumi.Output[builtins.str]:
|
|
1291
1409
|
"""
|
|
1292
1410
|
The CSR
|
|
1293
1411
|
"""
|
|
@@ -1295,7 +1413,7 @@ class SecretBackendIntermediateCertRequest(pulumi.CustomResource):
|
|
|
1295
1413
|
|
|
1296
1414
|
@property
|
|
1297
1415
|
@pulumi.getter(name="excludeCnFromSans")
|
|
1298
|
-
def exclude_cn_from_sans(self) -> pulumi.Output[Optional[bool]]:
|
|
1416
|
+
def exclude_cn_from_sans(self) -> pulumi.Output[Optional[builtins.bool]]:
|
|
1299
1417
|
"""
|
|
1300
1418
|
Flag to exclude CN from SANs
|
|
1301
1419
|
"""
|
|
@@ -1303,7 +1421,7 @@ class SecretBackendIntermediateCertRequest(pulumi.CustomResource):
|
|
|
1303
1421
|
|
|
1304
1422
|
@property
|
|
1305
1423
|
@pulumi.getter
|
|
1306
|
-
def format(self) -> pulumi.Output[Optional[str]]:
|
|
1424
|
+
def format(self) -> pulumi.Output[Optional[builtins.str]]:
|
|
1307
1425
|
"""
|
|
1308
1426
|
The format of data
|
|
1309
1427
|
"""
|
|
@@ -1311,7 +1429,7 @@ class SecretBackendIntermediateCertRequest(pulumi.CustomResource):
|
|
|
1311
1429
|
|
|
1312
1430
|
@property
|
|
1313
1431
|
@pulumi.getter(name="ipSans")
|
|
1314
|
-
def ip_sans(self) -> pulumi.Output[Optional[Sequence[str]]]:
|
|
1432
|
+
def ip_sans(self) -> pulumi.Output[Optional[Sequence[builtins.str]]]:
|
|
1315
1433
|
"""
|
|
1316
1434
|
List of alternative IPs
|
|
1317
1435
|
"""
|
|
@@ -1319,7 +1437,7 @@ class SecretBackendIntermediateCertRequest(pulumi.CustomResource):
|
|
|
1319
1437
|
|
|
1320
1438
|
@property
|
|
1321
1439
|
@pulumi.getter(name="keyBits")
|
|
1322
|
-
def key_bits(self) -> pulumi.Output[Optional[int]]:
|
|
1440
|
+
def key_bits(self) -> pulumi.Output[Optional[builtins.int]]:
|
|
1323
1441
|
"""
|
|
1324
1442
|
The number of bits to use
|
|
1325
1443
|
"""
|
|
@@ -1327,7 +1445,7 @@ class SecretBackendIntermediateCertRequest(pulumi.CustomResource):
|
|
|
1327
1445
|
|
|
1328
1446
|
@property
|
|
1329
1447
|
@pulumi.getter(name="keyId")
|
|
1330
|
-
def key_id(self) -> pulumi.Output[str]:
|
|
1448
|
+
def key_id(self) -> pulumi.Output[builtins.str]:
|
|
1331
1449
|
"""
|
|
1332
1450
|
The ID of the generated key.
|
|
1333
1451
|
"""
|
|
@@ -1335,7 +1453,7 @@ class SecretBackendIntermediateCertRequest(pulumi.CustomResource):
|
|
|
1335
1453
|
|
|
1336
1454
|
@property
|
|
1337
1455
|
@pulumi.getter(name="keyName")
|
|
1338
|
-
def key_name(self) -> pulumi.Output[str]:
|
|
1456
|
+
def key_name(self) -> pulumi.Output[builtins.str]:
|
|
1339
1457
|
"""
|
|
1340
1458
|
When a new key is created with this request, optionally specifies
|
|
1341
1459
|
the name for this. The global ref `default` may not be used as a name.
|
|
@@ -1344,7 +1462,7 @@ class SecretBackendIntermediateCertRequest(pulumi.CustomResource):
|
|
|
1344
1462
|
|
|
1345
1463
|
@property
|
|
1346
1464
|
@pulumi.getter(name="keyRef")
|
|
1347
|
-
def key_ref(self) -> pulumi.Output[str]:
|
|
1465
|
+
def key_ref(self) -> pulumi.Output[builtins.str]:
|
|
1348
1466
|
"""
|
|
1349
1467
|
Specifies the key (either default, by name, or by identifier) to use
|
|
1350
1468
|
for generating this request. Only suitable for `type=existing` requests.
|
|
@@ -1353,15 +1471,23 @@ class SecretBackendIntermediateCertRequest(pulumi.CustomResource):
|
|
|
1353
1471
|
|
|
1354
1472
|
@property
|
|
1355
1473
|
@pulumi.getter(name="keyType")
|
|
1356
|
-
def key_type(self) -> pulumi.Output[Optional[str]]:
|
|
1474
|
+
def key_type(self) -> pulumi.Output[Optional[builtins.str]]:
|
|
1357
1475
|
"""
|
|
1358
1476
|
The desired key type
|
|
1359
1477
|
"""
|
|
1360
1478
|
return pulumi.get(self, "key_type")
|
|
1361
1479
|
|
|
1480
|
+
@property
|
|
1481
|
+
@pulumi.getter(name="keyUsages")
|
|
1482
|
+
def key_usages(self) -> pulumi.Output[Optional[Sequence[builtins.str]]]:
|
|
1483
|
+
"""
|
|
1484
|
+
Specifies key_usage to encode in the generated certificate.
|
|
1485
|
+
"""
|
|
1486
|
+
return pulumi.get(self, "key_usages")
|
|
1487
|
+
|
|
1362
1488
|
@property
|
|
1363
1489
|
@pulumi.getter
|
|
1364
|
-
def locality(self) -> pulumi.Output[Optional[str]]:
|
|
1490
|
+
def locality(self) -> pulumi.Output[Optional[builtins.str]]:
|
|
1365
1491
|
"""
|
|
1366
1492
|
The locality
|
|
1367
1493
|
"""
|
|
@@ -1369,7 +1495,7 @@ class SecretBackendIntermediateCertRequest(pulumi.CustomResource):
|
|
|
1369
1495
|
|
|
1370
1496
|
@property
|
|
1371
1497
|
@pulumi.getter(name="managedKeyId")
|
|
1372
|
-
def managed_key_id(self) -> pulumi.Output[Optional[str]]:
|
|
1498
|
+
def managed_key_id(self) -> pulumi.Output[Optional[builtins.str]]:
|
|
1373
1499
|
"""
|
|
1374
1500
|
The ID of the previously configured managed key. This field is
|
|
1375
1501
|
required if `type` is `kms` and it conflicts with `managed_key_name`
|
|
@@ -1378,7 +1504,7 @@ class SecretBackendIntermediateCertRequest(pulumi.CustomResource):
|
|
|
1378
1504
|
|
|
1379
1505
|
@property
|
|
1380
1506
|
@pulumi.getter(name="managedKeyName")
|
|
1381
|
-
def managed_key_name(self) -> pulumi.Output[Optional[str]]:
|
|
1507
|
+
def managed_key_name(self) -> pulumi.Output[Optional[builtins.str]]:
|
|
1382
1508
|
"""
|
|
1383
1509
|
The name of the previously configured managed key. This field is
|
|
1384
1510
|
required if `type` is `kms` and it conflicts with `managed_key_id`
|
|
@@ -1387,7 +1513,7 @@ class SecretBackendIntermediateCertRequest(pulumi.CustomResource):
|
|
|
1387
1513
|
|
|
1388
1514
|
@property
|
|
1389
1515
|
@pulumi.getter
|
|
1390
|
-
def namespace(self) -> pulumi.Output[Optional[str]]:
|
|
1516
|
+
def namespace(self) -> pulumi.Output[Optional[builtins.str]]:
|
|
1391
1517
|
"""
|
|
1392
1518
|
The namespace to provision the resource in.
|
|
1393
1519
|
The value should not contain leading or trailing forward slashes.
|
|
@@ -1398,7 +1524,7 @@ class SecretBackendIntermediateCertRequest(pulumi.CustomResource):
|
|
|
1398
1524
|
|
|
1399
1525
|
@property
|
|
1400
1526
|
@pulumi.getter
|
|
1401
|
-
def organization(self) -> pulumi.Output[Optional[str]]:
|
|
1527
|
+
def organization(self) -> pulumi.Output[Optional[builtins.str]]:
|
|
1402
1528
|
"""
|
|
1403
1529
|
The organization
|
|
1404
1530
|
"""
|
|
@@ -1406,7 +1532,7 @@ class SecretBackendIntermediateCertRequest(pulumi.CustomResource):
|
|
|
1406
1532
|
|
|
1407
1533
|
@property
|
|
1408
1534
|
@pulumi.getter(name="otherSans")
|
|
1409
|
-
def other_sans(self) -> pulumi.Output[Optional[Sequence[str]]]:
|
|
1535
|
+
def other_sans(self) -> pulumi.Output[Optional[Sequence[builtins.str]]]:
|
|
1410
1536
|
"""
|
|
1411
1537
|
List of other SANs
|
|
1412
1538
|
"""
|
|
@@ -1414,7 +1540,7 @@ class SecretBackendIntermediateCertRequest(pulumi.CustomResource):
|
|
|
1414
1540
|
|
|
1415
1541
|
@property
|
|
1416
1542
|
@pulumi.getter
|
|
1417
|
-
def ou(self) -> pulumi.Output[Optional[str]]:
|
|
1543
|
+
def ou(self) -> pulumi.Output[Optional[builtins.str]]:
|
|
1418
1544
|
"""
|
|
1419
1545
|
The organization unit
|
|
1420
1546
|
"""
|
|
@@ -1422,7 +1548,7 @@ class SecretBackendIntermediateCertRequest(pulumi.CustomResource):
|
|
|
1422
1548
|
|
|
1423
1549
|
@property
|
|
1424
1550
|
@pulumi.getter(name="postalCode")
|
|
1425
|
-
def postal_code(self) -> pulumi.Output[Optional[str]]:
|
|
1551
|
+
def postal_code(self) -> pulumi.Output[Optional[builtins.str]]:
|
|
1426
1552
|
"""
|
|
1427
1553
|
The postal code
|
|
1428
1554
|
"""
|
|
@@ -1430,7 +1556,7 @@ class SecretBackendIntermediateCertRequest(pulumi.CustomResource):
|
|
|
1430
1556
|
|
|
1431
1557
|
@property
|
|
1432
1558
|
@pulumi.getter(name="privateKey")
|
|
1433
|
-
def private_key(self) -> pulumi.Output[str]:
|
|
1559
|
+
def private_key(self) -> pulumi.Output[builtins.str]:
|
|
1434
1560
|
"""
|
|
1435
1561
|
The private key
|
|
1436
1562
|
"""
|
|
@@ -1438,7 +1564,7 @@ class SecretBackendIntermediateCertRequest(pulumi.CustomResource):
|
|
|
1438
1564
|
|
|
1439
1565
|
@property
|
|
1440
1566
|
@pulumi.getter(name="privateKeyFormat")
|
|
1441
|
-
def private_key_format(self) -> pulumi.Output[Optional[str]]:
|
|
1567
|
+
def private_key_format(self) -> pulumi.Output[Optional[builtins.str]]:
|
|
1442
1568
|
"""
|
|
1443
1569
|
The private key format
|
|
1444
1570
|
"""
|
|
@@ -1446,7 +1572,7 @@ class SecretBackendIntermediateCertRequest(pulumi.CustomResource):
|
|
|
1446
1572
|
|
|
1447
1573
|
@property
|
|
1448
1574
|
@pulumi.getter(name="privateKeyType")
|
|
1449
|
-
def private_key_type(self) -> pulumi.Output[str]:
|
|
1575
|
+
def private_key_type(self) -> pulumi.Output[builtins.str]:
|
|
1450
1576
|
"""
|
|
1451
1577
|
The private key type
|
|
1452
1578
|
"""
|
|
@@ -1454,15 +1580,31 @@ class SecretBackendIntermediateCertRequest(pulumi.CustomResource):
|
|
|
1454
1580
|
|
|
1455
1581
|
@property
|
|
1456
1582
|
@pulumi.getter
|
|
1457
|
-
def province(self) -> pulumi.Output[Optional[str]]:
|
|
1583
|
+
def province(self) -> pulumi.Output[Optional[builtins.str]]:
|
|
1458
1584
|
"""
|
|
1459
1585
|
The province
|
|
1460
1586
|
"""
|
|
1461
1587
|
return pulumi.get(self, "province")
|
|
1462
1588
|
|
|
1589
|
+
@property
|
|
1590
|
+
@pulumi.getter(name="serialNumber")
|
|
1591
|
+
def serial_number(self) -> pulumi.Output[Optional[builtins.str]]:
|
|
1592
|
+
"""
|
|
1593
|
+
The requested Subject's named Serial Number
|
|
1594
|
+
"""
|
|
1595
|
+
return pulumi.get(self, "serial_number")
|
|
1596
|
+
|
|
1597
|
+
@property
|
|
1598
|
+
@pulumi.getter(name="signatureBits")
|
|
1599
|
+
def signature_bits(self) -> pulumi.Output[Optional[builtins.int]]:
|
|
1600
|
+
"""
|
|
1601
|
+
The number of bits to use in the signature algorithm
|
|
1602
|
+
"""
|
|
1603
|
+
return pulumi.get(self, "signature_bits")
|
|
1604
|
+
|
|
1463
1605
|
@property
|
|
1464
1606
|
@pulumi.getter(name="streetAddress")
|
|
1465
|
-
def street_address(self) -> pulumi.Output[Optional[str]]:
|
|
1607
|
+
def street_address(self) -> pulumi.Output[Optional[builtins.str]]:
|
|
1466
1608
|
"""
|
|
1467
1609
|
The street address
|
|
1468
1610
|
"""
|
|
@@ -1470,7 +1612,7 @@ class SecretBackendIntermediateCertRequest(pulumi.CustomResource):
|
|
|
1470
1612
|
|
|
1471
1613
|
@property
|
|
1472
1614
|
@pulumi.getter
|
|
1473
|
-
def type(self) -> pulumi.Output[str]:
|
|
1615
|
+
def type(self) -> pulumi.Output[builtins.str]:
|
|
1474
1616
|
"""
|
|
1475
1617
|
Type of intermediate to create. Must be either \\"exported\\" or \\"internal\\"
|
|
1476
1618
|
or \\"kms\\"
|
|
@@ -1479,7 +1621,7 @@ class SecretBackendIntermediateCertRequest(pulumi.CustomResource):
|
|
|
1479
1621
|
|
|
1480
1622
|
@property
|
|
1481
1623
|
@pulumi.getter(name="uriSans")
|
|
1482
|
-
def uri_sans(self) -> pulumi.Output[Optional[Sequence[str]]]:
|
|
1624
|
+
def uri_sans(self) -> pulumi.Output[Optional[Sequence[builtins.str]]]:
|
|
1483
1625
|
"""
|
|
1484
1626
|
List of alternative URIs
|
|
1485
1627
|
"""
|