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

GroupMemberGroupIdsArgs

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

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

Example Usage

Exclusive Member Groups

import * as pulumi from "@pulumi/pulumi";
import * as vault from "@pulumi/vault";
const internal = new vault.identity.Group("internal", {
    name: "internal",
    type: "internal",
    externalMemberGroupIds: true,
    metadata: {
        version: "2",
    },
});
const users = new vault.identity.Group("users", {
    name: "users",
    metadata: {
        version: "2",
    },
});
const members = new vault.identity.GroupMemberGroupIds("members", {
    exclusive: true,
    memberGroupIds: [users&#46;id],
    groupId: internal.id,
});
Content copied to clipboard
import pulumi
import pulumi_vault as vault
internal = vault.identity.Group("internal",
    name="internal",
    type="internal",
    external_member_group_ids=True,
    metadata={
        "version": "2",
    })
users = vault.identity.Group("users",
    name="users",
    metadata={
        "version": "2",
    })
members = vault.identity.GroupMemberGroupIds("members",
    exclusive=True,
    member_group_ids=[users&#46;id],
    group_id=internal.id)
Content copied to clipboard
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",
        ExternalMemberGroupIds = true,
        Metadata =
        {
            { "version", "2" },
        },
    });
    var users = new Vault.Identity.Group("users", new()
    {
        Name = "users",
        Metadata =
        {
            { "version", "2" },
        },
    });
    var members = new Vault.Identity.GroupMemberGroupIds("members", new()
    {
        Exclusive = true,
        MemberGroupIds = new[]
        {
            users.Id,
        },
        GroupId = @internal.Id,
    });
});
Content copied to clipboard
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"),
			ExternalMemberGroupIds: pulumi.Bool(true),
			Metadata: pulumi.StringMap{
				"version": pulumi.String("2"),
			},
		})
		if err != nil {
			return err
		}
		users, err := identity.NewGroup(ctx, "users", &identity.GroupArgs{
			Name: pulumi.String("users"),
			Metadata: pulumi.StringMap{
				"version": pulumi.String("2"),
			},
		})
		if err != nil {
			return err
		}
		_, err = identity.NewGroupMemberGroupIds(ctx, "members", &identity.GroupMemberGroupIdsArgs{
			Exclusive: pulumi.Bool(true),
			MemberGroupIds: pulumi.StringArray{
				users.ID(),
			},
			GroupId: internal.ID(),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
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.GroupMemberGroupIds;
import com.pulumi.vault.identity.GroupMemberGroupIdsArgs;
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")
            .externalMemberGroupIds(true)
            .metadata(Map.of("version", "2"))
            .build());
        var users = new Group("users", GroupArgs.builder()
            .name("users")
            .metadata(Map.of("version", "2"))
            .build());
        var members = new GroupMemberGroupIds("members", GroupMemberGroupIdsArgs.builder()
            .exclusive(true)
            .memberGroupIds(users.id())
            .groupId(internal.id())
            .build());
    }
}
Content copied to clipboard
resources:
  internal:
    type: vault:identity:Group
    properties:
      name: internal
      type: internal
      externalMemberGroupIds: true
      metadata:
        version: '2'
  users:
    type: vault:identity:Group
    properties:
      name: users
      metadata:
        version: '2'
  members:
    type: vault:identity:GroupMemberGroupIds
    properties:
      exclusive: true
      memberGroupIds:
        - ${users.id}
      groupId: ${internal.id}
Content copied to clipboard

Non-Exclusive Member Groups

import * as pulumi from "@pulumi/pulumi";
import * as vault from "@pulumi/vault";
const internal = new vault.identity.Group("internal", {
    name: "internal",
    type: "internal",
    externalMemberGroupIds: true,
    metadata: {
        version: "2",
    },
});
const users = new vault.identity.Group("users", {
    name: "users",
    metadata: {
        version: "2",
    },
});
const members = new vault.identity.GroupMemberGroupIds("members", {
    exclusive: false,
    memberGroupIds: [users&#46;id],
    groupId: internal.id,
});
Content copied to clipboard
import pulumi
import pulumi_vault as vault
internal = vault.identity.Group("internal",
    name="internal",
    type="internal",
    external_member_group_ids=True,
    metadata={
        "version": "2",
    })
users = vault.identity.Group("users",
    name="users",
    metadata={
        "version": "2",
    })
members = vault.identity.GroupMemberGroupIds("members",
    exclusive=False,
    member_group_ids=[users&#46;id],
    group_id=internal.id)
Content copied to clipboard
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",
        ExternalMemberGroupIds = true,
        Metadata =
        {
            { "version", "2" },
        },
    });
    var users = new Vault.Identity.Group("users", new()
    {
        Name = "users",
        Metadata =
        {
            { "version", "2" },
        },
    });
    var members = new Vault.Identity.GroupMemberGroupIds("members", new()
    {
        Exclusive = false,
        MemberGroupIds = new[]
        {
            users.Id,
        },
        GroupId = @internal.Id,
    });
});
Content copied to clipboard
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"),
			ExternalMemberGroupIds: pulumi.Bool(true),
			Metadata: pulumi.StringMap{
				"version": pulumi.String("2"),
			},
		})
		if err != nil {
			return err
		}
		users, err := identity.NewGroup(ctx, "users", &identity.GroupArgs{
			Name: pulumi.String("users"),
			Metadata: pulumi.StringMap{
				"version": pulumi.String("2"),
			},
		})
		if err != nil {
			return err
		}
		_, err = identity.NewGroupMemberGroupIds(ctx, "members", &identity.GroupMemberGroupIdsArgs{
			Exclusive: pulumi.Bool(false),
			MemberGroupIds: pulumi.StringArray{
				users.ID(),
			},
			GroupId: internal.ID(),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
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.GroupMemberGroupIds;
import com.pulumi.vault.identity.GroupMemberGroupIdsArgs;
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")
            .externalMemberGroupIds(true)
            .metadata(Map.of("version", "2"))
            .build());
        var users = new Group("users", GroupArgs.builder()
            .name("users")
            .metadata(Map.of("version", "2"))
            .build());
        var members = new GroupMemberGroupIds("members", GroupMemberGroupIdsArgs.builder()
            .exclusive(false)
            .memberGroupIds(users.id())
            .groupId(internal.id())
            .build());
    }
}
Content copied to clipboard
resources:
  internal:
    type: vault:identity:Group
    properties:
      name: internal
      type: internal
      externalMemberGroupIds: true
      metadata:
        version: '2'
  users:
    type: vault:identity:Group
    properties:
      name: users
      metadata:
        version: '2'
  members:
    type: vault:identity:GroupMemberGroupIds
    properties:
      exclusive: false
      memberGroupIds:
        - ${users.id}
      groupId: ${internal.id}
Content copied to clipboard

Constructors

Link copied to clipboard
constructor(exclusive: Output<Boolean>? = null, groupId: Output<String>? = null, memberGroupIds: Output<List<String>>? = null, namespace: Output<String>? = null)

Properties

Link copied to clipboard
val exclusive: Output<Boolean>? = null

Defaults to true. If true, this resource will take exclusive control of the member groups 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 groups specified in the resource are present in the group. When destroying the resource, the resource will ensure that the member groups specified in the resource are removed.

Link copied to clipboard
val groupId: Output<String>? = null

Group ID to assign member entities to.

Link copied to clipboard
val memberGroupIds: Output<List<String>>? = null

List of member groups that belong to the group

Link copied to clipboard
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

Link copied to clipboard
open override fun toJava(): GroupMemberGroupIdsArgs