azuredevops.getGroup

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

const exampleProject = azuredevops.getProject({
    name: "Example Project",
});
const exampleGroup = exampleProject.then(exampleProject => azuredevops.getGroup({
    projectId: exampleProject.id,
    name: "Example Group",
}));
export const groupId = exampleGroup.then(exampleGroup => exampleGroup.id);
export const groupDescriptor = exampleGroup.then(exampleGroup => exampleGroup.descriptor);
const example-collection-group = azuredevops.getGroup({
    name: "Project Collection Administrators",
});
export const collectionGroupId = exampleGroup.then(exampleGroup => exampleGroup.id);
export const collectionGroupDescriptor = exampleGroup.then(exampleGroup => exampleGroup.descriptor);

import pulumi
import pulumi_azuredevops as azuredevops

example_project = azuredevops.get_project(name="Example Project")
example_group = azuredevops.get_group(project_id=example_project.id,
    name="Example Group")
pulumi.export("groupId", example_group.id)
pulumi.export("groupDescriptor", example_group.descriptor)
example_collection_group = azuredevops.get_group(name="Project Collection Administrators")
pulumi.export("collectionGroupId", example_group.id)
pulumi.export("collectionGroupDescriptor", example_group.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.LookupProject(ctx, &azuredevops.LookupProjectArgs{
			Name: pulumi.StringRef("Example Project"),
		}, nil)
		if err != nil {
			return err
		}
		exampleGroup, err := azuredevops.LookupGroup(ctx, &azuredevops.LookupGroupArgs{
			ProjectId: pulumi.StringRef(exampleProject.Id),
			Name:      "Example Group",
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("groupId", exampleGroup.Id)
		ctx.Export("groupDescriptor", exampleGroup.Descriptor)
		_, err = azuredevops.LookupGroup(ctx, &azuredevops.LookupGroupArgs{
			Name: "Project Collection Administrators",
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("collectionGroupId", exampleGroup.Id)
		ctx.Export("collectionGroupDescriptor", exampleGroup.Descriptor)
		return nil
	})
}

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

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

    var exampleGroup = AzureDevOps.GetGroup.Invoke(new()
    {
        ProjectId = exampleProject.Apply(getProjectResult => getProjectResult.Id),
        Name = "Example Group",
    });

    var example_collection_group = AzureDevOps.GetGroup.Invoke(new()
    {
        Name = "Project Collection Administrators",
    });

    return new Dictionary<string, object?>
    {
        ["groupId"] = exampleGroup.Apply(getGroupResult => getGroupResult.Id),
        ["groupDescriptor"] = exampleGroup.Apply(getGroupResult => getGroupResult.Descriptor),
        ["collectionGroupId"] = exampleGroup.Apply(getGroupResult => getGroupResult.Id),
        ["collectionGroupDescriptor"] = exampleGroup.Apply(getGroupResult => getGroupResult.Descriptor),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azuredevops.AzuredevopsFunctions;
import com.pulumi.azuredevops.inputs.GetProjectArgs;
import com.pulumi.azuredevops.inputs.GetGroupArgs;
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) {
        final var exampleProject = AzuredevopsFunctions.getProject(GetProjectArgs.builder()
            .name("Example Project")
            .build());

        final var exampleGroup = AzuredevopsFunctions.getGroup(GetGroupArgs.builder()
            .projectId(exampleProject.applyValue(getProjectResult -> getProjectResult.id()))
            .name("Example Group")
            .build());

        ctx.export("groupId", exampleGroup.applyValue(getGroupResult -> getGroupResult.id()));
        ctx.export("groupDescriptor", exampleGroup.applyValue(getGroupResult -> getGroupResult.descriptor()));
        final var example-collection-group = AzuredevopsFunctions.getGroup(GetGroupArgs.builder()
            .name("Project Collection Administrators")
            .build());

        ctx.export("collectionGroupId", exampleGroup.applyValue(getGroupResult -> getGroupResult.id()));
        ctx.export("collectionGroupDescriptor", exampleGroup.applyValue(getGroupResult -> getGroupResult.descriptor()));
    }
}

variables:
  exampleProject:
    fn::invoke:
      Function: azuredevops:getProject
      Arguments:
        name: Example Project
  exampleGroup:
    fn::invoke:
      Function: azuredevops:getGroup
      Arguments:
        projectId: ${exampleProject.id}
        name: Example Group
  example-collection-group:
    fn::invoke:
      Function: azuredevops:getGroup
      Arguments:
        name: Project Collection Administrators
outputs:
  groupId: ${exampleGroup.id}
  groupDescriptor: ${exampleGroup.descriptor}
  collectionGroupId: ${exampleGroup.id}
  collectionGroupDescriptor: ${exampleGroup.descriptor}

function getGroup(args: GetGroupArgs, opts?: InvokeOptions): Promise<GetGroupResult>
function getGroupOutput(args: GetGroupOutputArgs, opts?: InvokeOptions): Output<GetGroupResult>

def get_group(name: Optional[str] = None,
              project_id: Optional[str] = None,
              opts: Optional[InvokeOptions] = None) -> GetGroupResult
def get_group_output(name: Optional[pulumi.Input[str]] = None,
              project_id: Optional[pulumi.Input[str]] = None,
              opts: Optional[InvokeOptions] = None) -> Output[GetGroupResult]

func LookupGroup(ctx *Context, args *LookupGroupArgs, opts ...InvokeOption) (*LookupGroupResult, error)
func LookupGroupOutput(ctx *Context, args *LookupGroupOutputArgs, opts ...InvokeOption) LookupGroupResultOutput

public static class GetGroup 
{
    public static Task<GetGroupResult> InvokeAsync(GetGroupArgs args, InvokeOptions? opts = null)
    public static Output<GetGroupResult> Invoke(GetGroupInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetGroupResult> getGroup(GetGroupArgs args, InvokeOptions options)
// Output-based functions aren't available in Java yet

fn::invoke:
  function: azuredevops:index/getGroup:getGroup
  arguments:
    # arguments dictionary