pulumi-vault-kotlin/com.pulumi.vault.kotlin/Audit

Audit

class Audit : KotlinCustomResource

Example Usage

File Audit Device)

import * as pulumi from "@pulumi/pulumi";
import * as vault from "@pulumi/vault";
const test = new vault.Audit("test", {
    type: "file",
    options: {
        file_path: "C:/temp/audit.txt",
    },
});

import pulumi
import pulumi_vault as vault
test = vault.Audit("test",
    type="file",
    options={
        "file_path": "C:/temp/audit.txt",
    })

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Vault = Pulumi.Vault;
return await Deployment.RunAsync(() =>
{
    var test = new Vault.Audit("test", new()
    {
        Type = "file",
        Options =
        {
            { "file_path", "C:/temp/audit.txt" },
        },
    });
});

package main
import (
	"github.com/pulumi/pulumi-vault/sdk/v6/go/vault"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := vault.NewAudit(ctx, "test", &vault.AuditArgs{
			Type: pulumi.String("file"),
			Options: pulumi.StringMap{
				"file_path": pulumi.String("C:/temp/audit.txt"),
			},
		})
		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.Audit;
import com.pulumi.vault.AuditArgs;
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 Audit("test", AuditArgs.builder()
            .type("file")
            .options(Map.of("file_path", "C:/temp/audit.txt"))
            .build());
    }
}

resources:
  test:
    type: vault:Audit
    properties:
      type: file
      options:
        file_path: C:/temp/audit.txt

Socket Audit Device)

import * as pulumi from "@pulumi/pulumi";
import * as vault from "@pulumi/vault";
const test = new vault.Audit("test", {
    type: "socket",
    path: "app_socket",
    local: false,
    options: {
        address: "127.0.0.1:8000",
        socket_type: "tcp",
        description: "application x socket",
    },
});

import pulumi
import pulumi_vault as vault
test = vault.Audit("test",
    type="socket",
    path="app_socket",
    local=False,
    options={
        "address": "127.0.0.1:8000",
        "socket_type": "tcp",
        "description": "application x socket",
    })

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Vault = Pulumi.Vault;
return await Deployment.RunAsync(() =>
{
    var test = new Vault.Audit("test", new()
    {
        Type = "socket",
        Path = "app_socket",
        Local = false,
        Options =
        {
            { "address", "127.0.0.1:8000" },
            { "socket_type", "tcp" },
            { "description", "application x socket" },
        },
    });
});

package main
import (
	"github.com/pulumi/pulumi-vault/sdk/v6/go/vault"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := vault.NewAudit(ctx, "test", &vault.AuditArgs{
			Type:  pulumi.String("socket"),
			Path:  pulumi.String("app_socket"),
			Local: pulumi.Bool(false),
			Options: pulumi.StringMap{
				"address":     pulumi.String("127.0.0.1:8000"),
				"socket_type": pulumi.String("tcp"),
				"description": pulumi.String("application x socket"),
			},
		})
		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.Audit;
import com.pulumi.vault.AuditArgs;
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 Audit("test", AuditArgs.builder()
            .type("socket")
            .path("app_socket")
            .local(false)
            .options(Map.ofEntries(
                Map.entry("address", "127.0.0.1:8000"),
                Map.entry("socket_type", "tcp"),
                Map.entry("description", "application x socket")
            ))
            .build());
    }
}

resources:
  test:
    type: vault:Audit
    properties:
      type: socket
      path: app_socket
      local: false
      options:
        address: 127.0.0.1:8000
        socket_type: tcp
        description: application x socket

Import

Audit devices can be imported using the path, e.g.

$ pulumi import vault:index/audit:Audit test syslog

Properties

description

val description: Output<String>?

Human-friendly description of the audit device.

val id: Output<String>

local

val local: Output<Boolean>?

Specifies if the audit device is a local only. Local audit devices are not replicated nor (if a secondary) removed by replication.

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.

options

val options: Output<Map<String, String>>

Configuration options to pass to the audit device itself. For a reference of the device types and their options, consult the Vault documentation.

path

val path: Output<String>

The path to mount the audit device. This defaults to the type.

pulumiChildResources

val pulumiChildResources: Set<KotlinResource>

pulumiResourceName

val pulumiResourceName: String

pulumiResourceType

val pulumiResourceType: String

type

val type: Output<String>

Type of the audit device, such as 'file'.

urn

val urn: Output<String>