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

GroupMemberEntityIdsArgs

data class GroupMemberEntityIdsArgs(val exclusive: Output<Boolean>? = null, val groupId: Output<String>? = null, val memberEntityIds: Output<List<String>>? = null, val namespace: Output<String>? = null) : ConvertibleToJava<GroupMemberEntityIdsArgs>

Manages member entities for an Identity Group for Vault. The Identity secrets engine is the identity management solution for Vault.

Example Usage

Exclusive Member Entities

import * as pulumi from "@pulumi/pulumi";
import * as vault from "@pulumi/vault";
const internal = new vault.identity.Group("internal", {
    name: "internal",
    type: "internal",
    externalMemberEntityIds: true,
    metadata: {
        version: "2",
    },
});
const user = new vault.identity.Entity("user", {name: "user"});
const members = new vault.identity.GroupMemberEntityIds("members", {
    exclusive: true,
    memberEntityIds: [user&#46;id],
    groupId: internal.id,
});

import pulumi
import pulumi_vault as vault
internal = vault.identity.Group("internal",
    name="internal",
    type="internal",
    external_member_entity_ids=True,
    metadata={
        "version": "2",
    })
user = vault.identity.Entity("user", name="user")
members = vault.identity.GroupMemberEntityIds("members",
    exclusive=True,
    member_entity_ids=[user&#46;id],
    group_id=internal.id)

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Vault = Pulumi.Vault;
return await Deployment.RunAsync(() =>
{
    var @internal = new Vault.Identity.Group("internal", new()
    {
        Name = "internal",
        Type = "internal",
        ExternalMemberEntityIds = true,
        Metadata =
        {
            { "version", "2" },
        },
    });
    var user = new Vault.Identity.Entity("user", new()
    {
        Name = "user",
    });
    var members = new Vault.Identity.GroupMemberEntityIds("members", new()
    {
        Exclusive = true,
        MemberEntityIds = new[]
        {
            user.Id,
        },
        GroupId = @internal.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 {
		internal, err := identity.NewGroup(ctx, "internal", &identity.GroupArgs{
			Name:                    pulumi.String("internal"),
			Type:                    pulumi.String("internal"),
			ExternalMemberEntityIds: pulumi.Bool(true),
			Metadata: pulumi.StringMap{
				"version": pulumi.String("2"),
			},
		})
		if err != nil {
			return err
		}
		user, err := identity.NewEntity(ctx, "user", &identity.EntityArgs{
			Name: pulumi.String("user"),
		})
		if err != nil {
			return err
		}
		_, err = identity.NewGroupMemberEntityIds(ctx, "members", &identity.GroupMemberEntityIdsArgs{
			Exclusive: pulumi.Bool(true),
			MemberEntityIds: pulumi.StringArray{
				user.ID(),
			},
			GroupId: internal.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.Group;
import com.pulumi.vault.identity.GroupArgs;
import com.pulumi.vault.identity.Entity;
import com.pulumi.vault.identity.EntityArgs;
import com.pulumi.vault.identity.GroupMemberEntityIds;
import com.pulumi.vault.identity.GroupMemberEntityIdsArgs;
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 internal = new Group("internal", GroupArgs.builder()
            .name("internal")
            .type("internal")
            .externalMemberEntityIds(true)
            .metadata(Map.of("version", "2"))
            .build());
        var user = new Entity("user", EntityArgs.builder()
            .name("user")
            .build());
        var members = new GroupMemberEntityIds("members", GroupMemberEntityIdsArgs.builder()
            .exclusive(true)
            .memberEntityIds(user.id())
            .groupId(internal.id())
            .build());
    }
}

resources:
  internal:
    type: vault:identity:Group
    properties:
      name: internal
      type: internal
      externalMemberEntityIds: true
      metadata:
        version: '2'
  user:
    type: vault:identity:Entity
    properties:
      name: user
  members:
    type: vault:identity:GroupMemberEntityIds
    properties:
      exclusive: true
      memberEntityIds:
        - ${user.id}
      groupId: ${internal.id}

Non-exclusive Member Entities

import * as pulumi from "@pulumi/pulumi";
import * as vault from "@pulumi/vault";
const internal = new vault.identity.Group("internal", {
    name: "internal",
    type: "internal",
    externalMemberEntityIds: true,
    metadata: {
        version: "2",
    },
});
const testUser = new vault.identity.Entity("test_user", {name: "test"});
const secondTestUser = new vault.identity.Entity("second_test_user", {name: "second_test"});
const devUser = new vault.identity.Entity("dev_user", {name: "dev"});
const test = new vault.identity.GroupMemberEntityIds("test", {
    memberEntityIds: [
        testUser.id,
        secondTestUser.id,
    ],
    exclusive: false,
    groupId: internal.id,
});
const others = new vault.identity.GroupMemberEntityIds("others", {
    memberEntityIds: [devUser&#46;id],
    exclusive: false,
    groupId: internal.id,
});

import pulumi
import pulumi_vault as vault
internal = vault.identity.Group("internal",
    name="internal",
    type="internal",
    external_member_entity_ids=True,
    metadata={
        "version": "2",
    })
test_user = vault.identity.Entity("test_user", name="test")
second_test_user = vault.identity.Entity("second_test_user", name="second_test")
dev_user = vault.identity.Entity("dev_user", name="dev")
test = vault.identity.GroupMemberEntityIds("test",
    member_entity_ids=[
        test_user.id,
        second_test_user.id,
    ],
    exclusive=False,
    group_id=internal.id)
others = vault.identity.GroupMemberEntityIds("others",
    member_entity_ids=[dev_user&#46;id],
    exclusive=False,
    group_id=internal.id)

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Vault = Pulumi.Vault;
return await Deployment.RunAsync(() =>
{
    var @internal = new Vault.Identity.Group("internal", new()
    {
        Name = "internal",
        Type = "internal",
        ExternalMemberEntityIds = true,
        Metadata =
        {
            { "version", "2" },
        },
    });
    var testUser = new Vault.Identity.Entity("test_user", new()
    {
        Name = "test",
    });
    var secondTestUser = new Vault.Identity.Entity("second_test_user", new()
    {
        Name = "second_test",
    });
    var devUser = new Vault.Identity.Entity("dev_user", new()
    {
        Name = "dev",
    });
    var test = new Vault.Identity.GroupMemberEntityIds("test", new()
    {
        MemberEntityIds = new[]
        {
            testUser.Id,
            secondTestUser.Id,
        },
        Exclusive = false,
        GroupId = @internal.Id,
    });
    var others = new Vault.Identity.GroupMemberEntityIds("others", new()
    {
        MemberEntityIds = new[]
        {
            devUser.Id,
        },
        Exclusive = false,
        GroupId = @internal.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 {
		internal, err := identity.NewGroup(ctx, "internal", &identity.GroupArgs{
			Name:                    pulumi.String("internal"),
			Type:                    pulumi.String("internal"),
			ExternalMemberEntityIds: pulumi.Bool(true),
			Metadata: pulumi.StringMap{
				"version": pulumi.String("2"),
			},
		})
		if err != nil {
			return err
		}
		testUser, err := identity.NewEntity(ctx, "test_user", &identity.EntityArgs{
			Name: pulumi.String("test"),
		})
		if err != nil {
			return err
		}
		secondTestUser, err := identity.NewEntity(ctx, "second_test_user", &identity.EntityArgs{
			Name: pulumi.String("second_test"),
		})
		if err != nil {
			return err
		}
		devUser, err := identity.NewEntity(ctx, "dev_user", &identity.EntityArgs{
			Name: pulumi.String("dev"),
		})
		if err != nil {
			return err
		}
		_, err = identity.NewGroupMemberEntityIds(ctx, "test", &identity.GroupMemberEntityIdsArgs{
			MemberEntityIds: pulumi.StringArray{
				testUser.ID(),
				secondTestUser.ID(),
			},
			Exclusive: pulumi.Bool(false),
			GroupId:   internal.ID(),
		})
		if err != nil {
			return err
		}
		_, err = identity.NewGroupMemberEntityIds(ctx, "others", &identity.GroupMemberEntityIdsArgs{
			MemberEntityIds: pulumi.StringArray{
				devUser.ID(),
			},
			Exclusive: pulumi.Bool(false),
			GroupId:   internal.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.Group;
import com.pulumi.vault.identity.GroupArgs;
import com.pulumi.vault.identity.Entity;
import com.pulumi.vault.identity.EntityArgs;
import com.pulumi.vault.identity.GroupMemberEntityIds;
import com.pulumi.vault.identity.GroupMemberEntityIdsArgs;
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 internal = new Group("internal", GroupArgs.builder()
            .name("internal")
            .type("internal")
            .externalMemberEntityIds(true)
            .metadata(Map.of("version", "2"))
            .build());
        var testUser = new Entity("testUser", EntityArgs.builder()
            .name("test")
            .build());
        var secondTestUser = new Entity("secondTestUser", EntityArgs.builder()
            .name("second_test")
            .build());
        var devUser = new Entity("devUser", EntityArgs.builder()
            .name("dev")
            .build());
        var test = new GroupMemberEntityIds("test", GroupMemberEntityIdsArgs.builder()
            .memberEntityIds(
                testUser.id(),
                secondTestUser.id())
            .exclusive(false)
            .groupId(internal.id())
            .build());
        var others = new GroupMemberEntityIds("others", GroupMemberEntityIdsArgs.builder()
            .memberEntityIds(devUser.id())
            .exclusive(false)
            .groupId(internal.id())
            .build());
    }
}

resources:
  internal:
    type: vault:identity:Group
    properties:
      name: internal
      type: internal
      externalMemberEntityIds: true
      metadata:
        version: '2'
  testUser:
    type: vault:identity:Entity
    name: test_user
    properties:
      name: test
  secondTestUser:
    type: vault:identity:Entity
    name: second_test_user
    properties:
      name: second_test
  devUser:
    type: vault:identity:Entity
    name: dev_user
    properties:
      name: dev
  test:
    type: vault:identity:GroupMemberEntityIds
    properties:
      memberEntityIds:
        - ${testUser.id}
        - ${secondTestUser.id}
      exclusive: false
      groupId: ${internal.id}
  others:
    type: vault:identity:GroupMemberEntityIds
    properties:
      memberEntityIds:
        - ${devUser.id}
      exclusive: false
      groupId: ${internal.id}

Constructors

GroupMemberEntityIdsArgs

constructor(exclusive: Output<Boolean>? = null, groupId: Output<String>? = null, memberEntityIds: Output<List<String>>? = null, namespace: Output<String>? = null)

Properties

exclusive

val exclusive: Output<Boolean>? = null

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

groupId

val groupId: Output<String>? = null

Group ID to assign member entities to.

memberEntityIds

val memberEntityIds: Output<List<String>>? = null

List of member entities that belong to the group

namespace

val namespace: Output<String>? = null

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.

Functions

toJava

open override fun toJava(): GroupMemberEntityIdsArgs