azure.core.getUserAssignedIdentity

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

const example = azure.authorization.getUserAssignedIdentity({
    name: "name_of_user_assigned_identity",
    resourceGroupName: "name_of_resource_group",
});
export const uaiClientId = example.then(example => example.clientId);
export const uaiPrincipalId = example.then(example => example.principalId);
export const uaiTenantId = example.then(example => example.tenantId);

import pulumi
import pulumi_azure as azure

example = azure.authorization.get_user_assigned_identity(name="name_of_user_assigned_identity",
    resource_group_name="name_of_resource_group")
pulumi.export("uaiClientId", example.client_id)
pulumi.export("uaiPrincipalId", example.principal_id)
pulumi.export("uaiTenantId", example.tenant_id)

package main

import (
	"github.com/pulumi/pulumi-azure/sdk/v6/go/azure/authorization"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := authorization.LookupUserAssignedIdentity(ctx, &authorization.LookupUserAssignedIdentityArgs{
			Name:              "name_of_user_assigned_identity",
			ResourceGroupName: "name_of_resource_group",
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("uaiClientId", example.ClientId)
		ctx.Export("uaiPrincipalId", example.PrincipalId)
		ctx.Export("uaiTenantId", example.TenantId)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var example = Azure.Authorization.GetUserAssignedIdentity.Invoke(new()
    {
        Name = "name_of_user_assigned_identity",
        ResourceGroupName = "name_of_resource_group",
    });

    return new Dictionary<string, object?>
    {
        ["uaiClientId"] = example.Apply(getUserAssignedIdentityResult => getUserAssignedIdentityResult.ClientId),
        ["uaiPrincipalId"] = example.Apply(getUserAssignedIdentityResult => getUserAssignedIdentityResult.PrincipalId),
        ["uaiTenantId"] = example.Apply(getUserAssignedIdentityResult => getUserAssignedIdentityResult.TenantId),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azure.authorization.AuthorizationFunctions;
import com.pulumi.azure.authorization.inputs.GetUserAssignedIdentityArgs;
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 example = AuthorizationFunctions.getUserAssignedIdentity(GetUserAssignedIdentityArgs.builder()
            .name("name_of_user_assigned_identity")
            .resourceGroupName("name_of_resource_group")
            .build());

        ctx.export("uaiClientId", example.applyValue(getUserAssignedIdentityResult -> getUserAssignedIdentityResult.clientId()));
        ctx.export("uaiPrincipalId", example.applyValue(getUserAssignedIdentityResult -> getUserAssignedIdentityResult.principalId()));
        ctx.export("uaiTenantId", example.applyValue(getUserAssignedIdentityResult -> getUserAssignedIdentityResult.tenantId()));
    }
}

variables:
  example:
    fn::invoke:
      Function: azure:authorization:getUserAssignedIdentity
      Arguments:
        name: name_of_user_assigned_identity
        resourceGroupName: name_of_resource_group
outputs:
  uaiClientId: ${example.clientId}
  uaiPrincipalId: ${example.principalId}
  uaiTenantId: ${example.tenantId}

function getUserAssignedIdentity(args: GetUserAssignedIdentityArgs, opts?: InvokeOptions): Promise<GetUserAssignedIdentityResult>
function getUserAssignedIdentityOutput(args: GetUserAssignedIdentityOutputArgs, opts?: InvokeOptions): Output<GetUserAssignedIdentityResult>

def get_user_assigned_identity(name: Optional[str] = None,
                               resource_group_name: Optional[str] = None,
                               opts: Optional[InvokeOptions] = None) -> GetUserAssignedIdentityResult
def get_user_assigned_identity_output(name: Optional[pulumi.Input[str]] = None,
                               resource_group_name: Optional[pulumi.Input[str]] = None,
                               opts: Optional[InvokeOptions] = None) -> Output[GetUserAssignedIdentityResult]

func GetUserAssignedIdentity(ctx *Context, args *GetUserAssignedIdentityArgs, opts ...InvokeOption) (*GetUserAssignedIdentityResult, error)
func GetUserAssignedIdentityOutput(ctx *Context, args *GetUserAssignedIdentityOutputArgs, opts ...InvokeOption) GetUserAssignedIdentityResultOutput

public static class GetUserAssignedIdentity 
{
    public static Task<GetUserAssignedIdentityResult> InvokeAsync(GetUserAssignedIdentityArgs args, InvokeOptions? opts = null)
    public static Output<GetUserAssignedIdentityResult> Invoke(GetUserAssignedIdentityInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetUserAssignedIdentityResult> getUserAssignedIdentity(GetUserAssignedIdentityArgs args, InvokeOptions options)
// Output-based functions aren't available in Java yet

fn::invoke:
  function: azure:core/getUserAssignedIdentity:getUserAssignedIdentity
  arguments:
    # arguments dictionary