azuredevops.GroupMembership

import * as pulumi from "@pulumi/pulumi";
import * as azuredevops from "@pulumi/azuredevops";

const exampleProject = new azuredevops.Project("example", {name: "Example Project"});
const exampleUser = new azuredevops.User("example", {principalName: "foo@contoso.com"});
const example = azuredevops.getGroupOutput({
    projectId: exampleProject.id,
    name: "Build Administrators",
});
const exampleGroupMembership = new azuredevops.GroupMembership("example", {
    group: example.apply(example => example.descriptor),
    members: [exampleUser.descriptor],
});

import pulumi
import pulumi_azuredevops as azuredevops

example_project = azuredevops.Project("example", name="Example Project")
example_user = azuredevops.User("example", principal_name="foo@contoso.com")
example = azuredevops.get_group_output(project_id=example_project.id,
    name="Build Administrators")
example_group_membership = azuredevops.GroupMembership("example",
    group=example.descriptor,
    members=[example_user.descriptor])

package main

import (
	"github.com/pulumi/pulumi-azuredevops/sdk/v3/go/azuredevops"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleProject, err := azuredevops.NewProject(ctx, "example", &azuredevops.ProjectArgs{
			Name: pulumi.String("Example Project"),
		})
		if err != nil {
			return err
		}
		exampleUser, err := azuredevops.NewUser(ctx, "example", &azuredevops.UserArgs{
			PrincipalName: pulumi.String("foo@contoso.com"),
		})
		if err != nil {
			return err
		}
		example := azuredevops.LookupGroupOutput(ctx, azuredevops.GetGroupOutputArgs{
			ProjectId: exampleProject.ID(),
			Name:      pulumi.String("Build Administrators"),
		}, nil)
		_, err = azuredevops.NewGroupMembership(ctx, "example", &azuredevops.GroupMembershipArgs{
			Group: pulumi.String(example.ApplyT(func(example azuredevops.GetGroupResult) (*string, error) {
				return &example.Descriptor, nil
			}).(pulumi.StringPtrOutput)),
			Members: pulumi.StringArray{
				exampleUser.Descriptor,
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureDevOps = Pulumi.AzureDevOps;

return await Deployment.RunAsync(() => 
{
    var exampleProject = new AzureDevOps.Project("example", new()
    {
        Name = "Example Project",
    });

    var exampleUser = new AzureDevOps.User("example", new()
    {
        PrincipalName = "foo@contoso.com",
    });

    var example = AzureDevOps.GetGroup.Invoke(new()
    {
        ProjectId = exampleProject.Id,
        Name = "Build Administrators",
    });

    var exampleGroupMembership = new AzureDevOps.GroupMembership("example", new()
    {
        Group = example.Apply(getGroupResult => getGroupResult.Descriptor),
        Members = new[]
        {
            exampleUser.Descriptor,
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azuredevops.Project;
import com.pulumi.azuredevops.ProjectArgs;
import com.pulumi.azuredevops.User;
import com.pulumi.azuredevops.UserArgs;
import com.pulumi.azuredevops.AzuredevopsFunctions;
import com.pulumi.azuredevops.inputs.GetGroupArgs;
import com.pulumi.azuredevops.GroupMembership;
import com.pulumi.azuredevops.GroupMembershipArgs;
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 exampleProject = new Project("exampleProject", ProjectArgs.builder()
            .name("Example Project")
            .build());

        var exampleUser = new User("exampleUser", UserArgs.builder()
            .principalName("foo@contoso.com")
            .build());

        final var example = AzuredevopsFunctions.getGroup(GetGroupArgs.builder()
            .projectId(exampleProject.id())
            .name("Build Administrators")
            .build());

        var exampleGroupMembership = new GroupMembership("exampleGroupMembership", GroupMembershipArgs.builder()
            .group(example.applyValue(getGroupResult -> getGroupResult).applyValue(example -> example.applyValue(getGroupResult -> getGroupResult.descriptor())))
            .members(exampleUser.descriptor())
            .build());

    }
}

resources:
  exampleProject:
    type: azuredevops:Project
    name: example
    properties:
      name: Example Project
  exampleUser:
    type: azuredevops:User
    name: example
    properties:
      principalName: foo@contoso.com
  exampleGroupMembership:
    type: azuredevops:GroupMembership
    name: example
    properties:
      group: ${example.descriptor}
      members:
        - ${exampleUser.descriptor}
variables:
  example:
    fn::invoke:
      Function: azuredevops:getGroup
      Arguments:
        projectId: ${exampleProject.id}
        name: Build Administrators

var groupMembershipResource = new AzureDevOps.GroupMembership("groupMembershipResource", new()
{
    Group = "string",
    Members = new[]
    {
        "string",
    },
    Mode = "string",
});

example, err := azuredevops.NewGroupMembership(ctx, "groupMembershipResource", &azuredevops.GroupMembershipArgs{
	Group: pulumi.String("string"),
	Members: pulumi.StringArray{
		pulumi.String("string"),
	},
	Mode: pulumi.String("string"),
})

var groupMembershipResource = new GroupMembership("groupMembershipResource", GroupMembershipArgs.builder()
    .group("string")
    .members("string")
    .mode("string")
    .build());

group_membership_resource = azuredevops.GroupMembership("groupMembershipResource",
    group="string",
    members=["string"],
    mode="string")

const groupMembershipResource = new azuredevops.GroupMembership("groupMembershipResource", {
    group: "string",
    members: ["string"],
    mode: "string",
});

type: azuredevops:GroupMembership
properties:
    group: string
    members:
        - string
    mode: string