pulumi-vault-kotlin/com.pulumi.vault.pkiSecret.kotlin/SecretBackendConfigUrls

SecretBackendConfigUrls

class SecretBackendConfigUrls : KotlinCustomResource

Allows setting the issuing certificate endpoints, CRL distribution points, and OCSP server endpoints that will be encoded into issued certificates.

Example Usage

import * as pulumi from "@pulumi/pulumi";
import * as vault from "@pulumi/vault";
const root = new vault.Mount("root", {
    path: "pki-root",
    type: "pki",
    description: "root PKI",
    defaultLeaseTtlSeconds: 8640000,
    maxLeaseTtlSeconds: 8640000,
});
const example = new vault.pkisecret.SecretBackendConfigUrls("example", {
    backend: root.path,
    issuingCertificates: ["http://127&#46;0&#46;0&#46;1:8200/v1/pki/ca"],
});

import pulumi
import pulumi_vault as vault
root = vault.Mount("root",
    path="pki-root",
    type="pki",
    description="root PKI",
    default_lease_ttl_seconds=8640000,
    max_lease_ttl_seconds=8640000)
example = vault.pki_secret.SecretBackendConfigUrls("example",
    backend=root.path,
    issuing_certificates=["http://127&#46;0&#46;0&#46;1:8200/v1/pki/ca"])

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Vault = Pulumi.Vault;
return await Deployment.RunAsync(() =>
{
    var root = new Vault.Mount("root", new()
    {
        Path = "pki-root",
        Type = "pki",
        Description = "root PKI",
        DefaultLeaseTtlSeconds = 8640000,
        MaxLeaseTtlSeconds = 8640000,
    });
    var example = new Vault.PkiSecret.SecretBackendConfigUrls("example", new()
    {
        Backend = root.Path,
        IssuingCertificates = new[]
        {
            "http://127.0.0.1:8200/v1/pki/ca",
        },
    });
});

package main
import (
	"github.com/pulumi/pulumi-vault/sdk/v6/go/vault"
	"github.com/pulumi/pulumi-vault/sdk/v6/go/vault/pkisecret"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		root, err := vault.NewMount(ctx, "root", &vault.MountArgs{
			Path:                   pulumi.String("pki-root"),
			Type:                   pulumi.String("pki"),
			Description:            pulumi.String("root PKI"),
			DefaultLeaseTtlSeconds: pulumi.Int(8640000),
			MaxLeaseTtlSeconds:     pulumi.Int(8640000),
		})
		if err != nil {
			return err
		}
		_, err = pkisecret.NewSecretBackendConfigUrls(ctx, "example", &pkisecret.SecretBackendConfigUrlsArgs{
			Backend: root.Path,
			IssuingCertificates: pulumi.StringArray{
				pulumi.String("http://127.0.0.1:8200/v1/pki/ca"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.vault.Mount;
import com.pulumi.vault.MountArgs;
import com.pulumi.vault.pkiSecret.SecretBackendConfigUrls;
import com.pulumi.vault.pkiSecret.SecretBackendConfigUrlsArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }
    public static void stack(Context ctx) {
        var root = new Mount("root", MountArgs.builder()
            .path("pki-root")
            .type("pki")
            .description("root PKI")
            .defaultLeaseTtlSeconds(8640000)
            .maxLeaseTtlSeconds(8640000)
            .build());
        var example = new SecretBackendConfigUrls("example", SecretBackendConfigUrlsArgs.builder()
            .backend(root.path())
            .issuingCertificates("http://127.0.0.1:8200/v1/pki/ca")
            .build());
    }
}

resources:
  root:
    type: vault:Mount
    properties:
      path: pki-root
      type: pki
      description: root PKI
      defaultLeaseTtlSeconds: 8.64e+06
      maxLeaseTtlSeconds: 8.64e+06
  example:
    type: vault:pkiSecret:SecretBackendConfigUrls
    properties:
      backend: ${root.path}
      issuingCertificates:
        - http://127.0.0.1:8200/v1/pki/ca

Import

The PKI config URLs can be imported using the resource's id. In the case of the example above the id would be pki-root/config/urls, where the pki-root component is the resource's backend, e.g.

$ pulumi import vault:pkiSecret/secretBackendConfigUrls:SecretBackendConfigUrls example pki-root/config/urls

Properties

backend

val backend: Output<String>

The path the PKI secret backend is mounted at, with no leading or trailing /s.

crlDistributionPoints

val crlDistributionPoints: Output<List<String>>?

Specifies the URL values for the CRL Distribution Points field.

enableTemplating

val enableTemplating: Output<Boolean>?

Specifies that templating of AIA fields is allowed.

val id: Output<String>

issuingCertificates

val issuingCertificates: Output<List<String>>?

Specifies the URL values for the Issuing Certificate field.

namespace

val namespace: Output<String>?

The namespace to provision the resource in. The value should not contain leading or trailing forward slashes. The namespace is always relative to the provider's configured namespace. Available only for Vault Enterprise.

ocspServers

val ocspServers: Output<List<String>>?

Specifies the URL values for the OCSP Servers field.

pulumiChildResources

val pulumiChildResources: Set<KotlinResource>

pulumiResourceName

val pulumiResourceName: String

pulumiResourceType

val pulumiResourceType: String

urn

val urn: Output<String>