databricks.getServicePrincipals

import * as pulumi from "@pulumi/pulumi";
import * as databricks from "@pulumi/databricks";
import * as std from "@pulumi/std";

export = async () => {
    const admins = await databricks.getGroup({
        displayName: "admins",
    });
    const spns = await databricks.getServicePrincipals({
        displayNameContains: "my-spn",
    });
    const spn = .reduce((__obj, [__key, __value]) => ({ ...__obj, [__key]: await databricks.getServicePrincipal({
        applicationId: __value,
    }) }));
    const myMemberSpn: databricks.GroupMember[] = [];
    for (const range of std.toset({
        input: spns.applicationIds,
    }).result.map((v, k) => ({key: k, value: v}))) {
        myMemberSpn.push(new databricks.GroupMember(`my_member_spn-${range.key}`, {
            groupId: admins.id,
            memberId: spn[range.value].spId,
        }));
    }
}

import pulumi
import pulumi_databricks as databricks
import pulumi_std as std

admins = databricks.get_group(display_name="admins")
spns = databricks.get_service_principals(display_name_contains="my-spn")
spn = {__key: databricks.get_service_principal(application_id=__value) for __key, __value in std.toset(input=spns.application_ids).result}
my_member_spn = []
for range in [{"key": k, "value": v} for [k, v] in enumerate(std.toset(input=spns.application_ids).result)]:
    my_member_spn.append(databricks.GroupMember(f"my_member_spn-{range['key']}",
        group_id=admins.id,
        member_id=spn[range["value"]].sp_id))

using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Pulumi;
using Databricks = Pulumi.Databricks;
using Std = Pulumi.Std;

return await Deployment.RunAsync(async() => 
{
    var admins = await Databricks.GetGroup.InvokeAsync(new()
    {
        DisplayName = "admins",
    });

    var spns = await Databricks.GetServicePrincipals.InvokeAsync(new()
    {
        DisplayNameContains = "my-spn",
    });

    var spn = ;

    var myMemberSpn = new List<Databricks.GroupMember>();
    foreach (var range in )
    {
        myMemberSpn.Add(new Databricks.GroupMember($"my_member_spn-{range.Key}", new()
        {
            GroupId = admins.Id,
            MemberId = spn[range.Value].SpId,
        }));
    }
});

function getServicePrincipals(args: GetServicePrincipalsArgs, opts?: InvokeOptions): Promise<GetServicePrincipalsResult>
function getServicePrincipalsOutput(args: GetServicePrincipalsOutputArgs, opts?: InvokeOptions): Output<GetServicePrincipalsResult>

def get_service_principals(application_ids: Optional[Sequence[str]] = None,
                           display_name_contains: Optional[str] = None,
                           opts: Optional[InvokeOptions] = None) -> GetServicePrincipalsResult
def get_service_principals_output(application_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                           display_name_contains: Optional[pulumi.Input[str]] = None,
                           opts: Optional[InvokeOptions] = None) -> Output[GetServicePrincipalsResult]

func GetServicePrincipals(ctx *Context, args *GetServicePrincipalsArgs, opts ...InvokeOption) (*GetServicePrincipalsResult, error)
func GetServicePrincipalsOutput(ctx *Context, args *GetServicePrincipalsOutputArgs, opts ...InvokeOption) GetServicePrincipalsResultOutput

public static class GetServicePrincipals 
{
    public static Task<GetServicePrincipalsResult> InvokeAsync(GetServicePrincipalsArgs args, InvokeOptions? opts = null)
    public static Output<GetServicePrincipalsResult> Invoke(GetServicePrincipalsInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetServicePrincipalsResult> getServicePrincipals(GetServicePrincipalsArgs args, InvokeOptions options)
public static Output<GetServicePrincipalsResult> getServicePrincipals(GetServicePrincipalsArgs args, InvokeOptions options)

fn::invoke:
  function: databricks:index/getServicePrincipals:getServicePrincipals
  arguments:
    # arguments dictionary