SecretBackendRootCert

import * as pulumi from "@pulumi/pulumi";
import * as vault from "@pulumi/vault";
const test = new vault.pkisecret.SecretBackendRootCert("test", {
    backend: pki.path,
    type: "internal",
    commonName: "Root CA",
    ttl: "315360000",
    format: "pem",
    privateKeyFormat: "der",
    keyType: "rsa",
    keyBits: 4096,
    excludeCnFromSans: true,
    ou: "My OU",
    organization: "My organization",
}, {
    dependsOn: [pki],
});

import pulumi
import pulumi_vault as vault
test = vault.pki_secret.SecretBackendRootCert("test",
    backend=pki["path"],
    type="internal",
    common_name="Root CA",
    ttl="315360000",
    format="pem",
    private_key_format="der",
    key_type="rsa",
    key_bits=4096,
    exclude_cn_from_sans=True,
    ou="My OU",
    organization="My organization",
    opts = pulumi.ResourceOptions(depends_on=[pki]))

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Vault = Pulumi.Vault;
return await Deployment.RunAsync(() =>
{
    var test = new Vault.PkiSecret.SecretBackendRootCert("test", new()
    {
        Backend = pki.Path,
        Type = "internal",
        CommonName = "Root CA",
        Ttl = "315360000",
        Format = "pem",
        PrivateKeyFormat = "der",
        KeyType = "rsa",
        KeyBits = 4096,
        ExcludeCnFromSans = true,
        Ou = "My OU",
        Organization = "My organization",
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            pki,
        },
    });
});

package main
import (
	"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 {
		_, err := pkisecret.NewSecretBackendRootCert(ctx, "test", &pkisecret.SecretBackendRootCertArgs{
			Backend:           pulumi.Any(pki.Path),
			Type:              pulumi.String("internal"),
			CommonName:        pulumi.String("Root CA"),
			Ttl:               pulumi.String("315360000"),
			Format:            pulumi.String("pem"),
			PrivateKeyFormat:  pulumi.String("der"),
			KeyType:           pulumi.String("rsa"),
			KeyBits:           pulumi.Int(4096),
			ExcludeCnFromSans: pulumi.Bool(true),
			Ou:                pulumi.String("My OU"),
			Organization:      pulumi.String("My organization"),
		}, pulumi.DependsOn([]pulumi.Resource{
			pki,
		}))
		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.pkiSecret.SecretBackendRootCert;
import com.pulumi.vault.pkiSecret.SecretBackendRootCertArgs;
import com.pulumi.resources.CustomResourceOptions;
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 test = new SecretBackendRootCert("test", SecretBackendRootCertArgs.builder()
            .backend(pki.path())
            .type("internal")
            .commonName("Root CA")
            .ttl("315360000")
            .format("pem")
            .privateKeyFormat("der")
            .keyType("rsa")
            .keyBits(4096)
            .excludeCnFromSans(true)
            .ou("My OU")
            .organization("My organization")
            .build(), CustomResourceOptions.builder()
                .dependsOn(pki)
                .build());
    }
}

resources:
  test:
    type: vault:pkiSecret:SecretBackendRootCert
    properties:
      backend: ${pki.path}
      type: internal
      commonName: Root CA
      ttl: '315360000'
      format: pem
      privateKeyFormat: der
      keyType: rsa
      keyBits: 4096
      excludeCnFromSans: true
      ou: My OU
      organization: My organization
    options:
      dependsOn:
        - ${pki}