pulumi-vault-kotlin/com.pulumi.vault.identity.kotlin/EntityPolicies

EntityPolicies

class EntityPolicies : KotlinCustomResource

Manages policies for an Identity Entity for Vault. The Identity secrets engine is the identity management solution for Vault.

Example Usage

Exclusive Policies

import * as pulumi from "@pulumi/pulumi";
import * as vault from "@pulumi/vault";
const entity = new vault.identity.Entity("entity", {
    name: "entity",
    externalPolicies: true,
});
const policies = new vault.identity.EntityPolicies("policies", {
    policies: [
        "default",
        "test",
    ],
    exclusive: true,
    entityId: entity.id,
});

import pulumi
import pulumi_vault as vault
entity = vault.identity.Entity("entity",
    name="entity",
    external_policies=True)
policies = vault.identity.EntityPolicies("policies",
    policies=[
        "default",
        "test",
    ],
    exclusive=True,
    entity_id=entity.id)

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Vault = Pulumi.Vault;
return await Deployment.RunAsync(() =>
{
    var entity = new Vault.Identity.Entity("entity", new()
    {
        Name = "entity",
        ExternalPolicies = true,
    });
    var policies = new Vault.Identity.EntityPolicies("policies", new()
    {
        Policies = new[]
        {
            "default",
            "test",
        },
        Exclusive = true,
        EntityId = entity.Id,
    });
});

package main
import (
	"github.com/pulumi/pulumi-vault/sdk/v6/go/vault/identity"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		entity, err := identity.NewEntity(ctx, "entity", &identity.EntityArgs{
			Name:             pulumi.String("entity"),
			ExternalPolicies: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		_, err = identity.NewEntityPolicies(ctx, "policies", &identity.EntityPoliciesArgs{
			Policies: pulumi.StringArray{
				pulumi.String("default"),
				pulumi.String("test"),
			},
			Exclusive: pulumi.Bool(true),
			EntityId:  entity.ID(),
		})
		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.identity.Entity;
import com.pulumi.vault.identity.EntityArgs;
import com.pulumi.vault.identity.EntityPolicies;
import com.pulumi.vault.identity.EntityPoliciesArgs;
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 entity = new Entity("entity", EntityArgs.builder()
            .name("entity")
            .externalPolicies(true)
            .build());
        var policies = new EntityPolicies("policies", EntityPoliciesArgs.builder()
            .policies(
                "default",
                "test")
            .exclusive(true)
            .entityId(entity.id())
            .build());
    }
}

resources:
  entity:
    type: vault:identity:Entity
    properties:
      name: entity
      externalPolicies: true
  policies:
    type: vault:identity:EntityPolicies
    properties:
      policies:
        - default
        - test
      exclusive: true
      entityId: ${entity.id}

Non-exclusive Policies

import * as pulumi from "@pulumi/pulumi";
import * as vault from "@pulumi/vault";
const entity = new vault.identity.Entity("entity", {
    name: "entity",
    externalPolicies: true,
});
const _default = new vault.identity.EntityPolicies("default", {
    policies: [
        "default",
        "test",
    ],
    exclusive: false,
    entityId: entity.id,
});
const others = new vault.identity.EntityPolicies("others", {
    policies: ["others"],
    exclusive: false,
    entityId: entity.id,
});

import pulumi
import pulumi_vault as vault
entity = vault.identity.Entity("entity",
    name="entity",
    external_policies=True)
default = vault.identity.EntityPolicies("default",
    policies=[
        "default",
        "test",
    ],
    exclusive=False,
    entity_id=entity.id)
others = vault.identity.EntityPolicies("others",
    policies=["others"],
    exclusive=False,
    entity_id=entity.id)

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Vault = Pulumi.Vault;
return await Deployment.RunAsync(() =>
{
    var entity = new Vault.Identity.Entity("entity", new()
    {
        Name = "entity",
        ExternalPolicies = true,
    });
    var @default = new Vault.Identity.EntityPolicies("default", new()
    {
        Policies = new[]
        {
            "default",
            "test",
        },
        Exclusive = false,
        EntityId = entity.Id,
    });
    var others = new Vault.Identity.EntityPolicies("others", new()
    {
        Policies = new[]
        {
            "others",
        },
        Exclusive = false,
        EntityId = entity.Id,
    });
});

package main
import (
	"github.com/pulumi/pulumi-vault/sdk/v6/go/vault/identity"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		entity, err := identity.NewEntity(ctx, "entity", &identity.EntityArgs{
			Name:             pulumi.String("entity"),
			ExternalPolicies: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		_, err = identity.NewEntityPolicies(ctx, "default", &identity.EntityPoliciesArgs{
			Policies: pulumi.StringArray{
				pulumi.String("default"),
				pulumi.String("test"),
			},
			Exclusive: pulumi.Bool(false),
			EntityId:  entity.ID(),
		})
		if err != nil {
			return err
		}
		_, err = identity.NewEntityPolicies(ctx, "others", &identity.EntityPoliciesArgs{
			Policies: pulumi.StringArray{
				pulumi.String("others"),
			},
			Exclusive: pulumi.Bool(false),
			EntityId:  entity.ID(),
		})
		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.identity.Entity;
import com.pulumi.vault.identity.EntityArgs;
import com.pulumi.vault.identity.EntityPolicies;
import com.pulumi.vault.identity.EntityPoliciesArgs;
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 entity = new Entity("entity", EntityArgs.builder()
            .name("entity")
            .externalPolicies(true)
            .build());
        var default_ = new EntityPolicies("default", EntityPoliciesArgs.builder()
            .policies(
                "default",
                "test")
            .exclusive(false)
            .entityId(entity.id())
            .build());
        var others = new EntityPolicies("others", EntityPoliciesArgs.builder()
            .policies("others")
            .exclusive(false)
            .entityId(entity.id())
            .build());
    }
}

resources:
  entity:
    type: vault:identity:Entity
    properties:
      name: entity
      externalPolicies: true
  default:
    type: vault:identity:EntityPolicies
    properties:
      policies:
        - default
        - test
      exclusive: false
      entityId: ${entity.id}
  others:
    type: vault:identity:EntityPolicies
    properties:
      policies:
        - others
      exclusive: false
      entityId: ${entity.id}

Properties

entityId

val entityId: Output<String>

Entity ID to assign policies to.

entityName

val entityName: Output<String>

The name of the entity that are assigned the policies.

exclusive

val exclusive: Output<Boolean>?

Defaults to true. If true, this resource will take exclusive control of the policies assigned to the entity and will set it equal to what is specified in the resource. If set to false, this resource will simply ensure that the policies specified in the resource are present in the entity. When destroying the resource, the resource will ensure that the policies specified in the resource are removed.

val id: Output<String>

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.

policies

val policies: Output<List<String>>

List of policies to assign to the entity

pulumiChildResources

val pulumiChildResources: Set<KotlinResource>

pulumiResourceName

val pulumiResourceName: String

pulumiResourceType

val pulumiResourceType: String

urn

val urn: Output<String>