vault.appRole.getAuthBackendRoleId

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

export = async () => {
    const role = await vault.appRole.getAuthBackendRoleId({
        backend: "my-approle-backend",
        roleName: "my-role",
    });
    return {
        "role-id": role.roleId,
    };
}

import pulumi
import pulumi_vault as vault

role = vault.appRole.get_auth_backend_role_id(backend="my-approle-backend",
    role_name="my-role")
pulumi.export("role-id", role.role_id)

package main

import (
	"github.com/pulumi/pulumi-vault/sdk/v6/go/vault/appRole"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		role, err := appRole.GetAuthBackendRoleId(ctx, &approle.GetAuthBackendRoleIdArgs{
			Backend:  pulumi.StringRef("my-approle-backend"),
			RoleName: "my-role",
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("role-id", role.RoleId)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var role = Vault.AppRole.GetAuthBackendRoleId.Invoke(new()
    {
        Backend = "my-approle-backend",
        RoleName = "my-role",
    });

    return new Dictionary<string, object?>
    {
        ["role-id"] = role.Apply(getAuthBackendRoleIdResult => getAuthBackendRoleIdResult.RoleId),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.vault.appRole.AppRoleFunctions;
import com.pulumi.vault.appRole.inputs.GetAuthBackendRoleIdArgs;
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 role = AppRoleFunctions.getAuthBackendRoleId(GetAuthBackendRoleIdArgs.builder()
            .backend("my-approle-backend")
            .roleName("my-role")
            .build());

        ctx.export("role-id", role.applyValue(getAuthBackendRoleIdResult -> getAuthBackendRoleIdResult.roleId()));
    }
}

variables:
  role:
    fn::invoke:
      Function: vault:appRole:getAuthBackendRoleId
      Arguments:
        backend: my-approle-backend
        roleName: my-role
outputs:
  role-id: ${role.roleId}

function getAuthBackendRoleId(args: GetAuthBackendRoleIdArgs, opts?: InvokeOptions): Promise<GetAuthBackendRoleIdResult>
function getAuthBackendRoleIdOutput(args: GetAuthBackendRoleIdOutputArgs, opts?: InvokeOptions): Output<GetAuthBackendRoleIdResult>

def get_auth_backend_role_id(backend: Optional[str] = None,
                             namespace: Optional[str] = None,
                             role_name: Optional[str] = None,
                             opts: Optional[InvokeOptions] = None) -> GetAuthBackendRoleIdResult
def get_auth_backend_role_id_output(backend: Optional[pulumi.Input[str]] = None,
                             namespace: Optional[pulumi.Input[str]] = None,
                             role_name: Optional[pulumi.Input[str]] = None,
                             opts: Optional[InvokeOptions] = None) -> Output[GetAuthBackendRoleIdResult]

func GetAuthBackendRoleId(ctx *Context, args *GetAuthBackendRoleIdArgs, opts ...InvokeOption) (*GetAuthBackendRoleIdResult, error)
func GetAuthBackendRoleIdOutput(ctx *Context, args *GetAuthBackendRoleIdOutputArgs, opts ...InvokeOption) GetAuthBackendRoleIdResultOutput

public static class GetAuthBackendRoleId 
{
    public static Task<GetAuthBackendRoleIdResult> InvokeAsync(GetAuthBackendRoleIdArgs args, InvokeOptions? opts = null)
    public static Output<GetAuthBackendRoleIdResult> Invoke(GetAuthBackendRoleIdInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetAuthBackendRoleIdResult> getAuthBackendRoleId(GetAuthBackendRoleIdArgs args, InvokeOptions options)
// Output-based functions aren't available in Java yet

fn::invoke:
  function: vault:appRole/getAuthBackendRoleId:getAuthBackendRoleId
  arguments:
    # arguments dictionary