getUser function

Future<GetUserResult> getUser(
  1. GetUserArgs args, {
  2. InvokeOptions? options,
})

Use this data source to get an Identity Store User.

Example Usage

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

const example = aws.ssoadmin.getInstances({});
const exampleGetUser = example.then(example => aws.identitystore.getUser({
    alternateIdentifier: {
        uniqueAttribute: {
            attributePath: "UserName",
            attributeValue: "ExampleUser",
        },
    },
    identityStoreId: example.identityStoreIds?.[0],
}));
export const userId = exampleGetUser.then(exampleGetUser => exampleGetUser.userId);
import pulumi
import pulumi_aws as aws

example = aws.ssoadmin.get_instances()
example_get_user = aws.identitystore.get_user(alternate_identifier={
        "unique_attribute": {
            "attribute_path": "UserName",
            "attribute_value": "ExampleUser",
        },
    },
    identity_store_id=example.identity_store_ids[0])
pulumi.export("userId", example_get_user.user_id)
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = Aws.SsoAdmin.GetInstances.Invoke();

    var exampleGetUser = Aws.IdentityStore.GetUser.Invoke(new()
    {
        AlternateIdentifier = new Aws.IdentityStore.Inputs.GetUserAlternateIdentifierInputArgs
        {
            UniqueAttribute = new Aws.IdentityStore.Inputs.GetUserAlternateIdentifierUniqueAttributeInputArgs
            {
                AttributePath = "UserName",
                AttributeValue = "ExampleUser",
            },
        },
        IdentityStoreId = example.Apply(getInstancesResult => getInstancesResult.IdentityStoreIds[0]),
    });

    return new Dictionary<string, object?>
    {
        ["userId"] = exampleGetUser.Apply(getUserResult => getUserResult.UserId),
    };
});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/identitystore"
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ssoadmin"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := ssoadmin.GetInstances(ctx, &ssoadmin.GetInstancesArgs{}, nil)
		if err != nil {
			return err
		}
		exampleGetUser, err := identitystore.LookupUser(ctx, &identitystore.LookupUserArgs{
			AlternateIdentifier: identitystore.GetUserAlternateIdentifier{
				UniqueAttribute: identitystore.GetUserAlternateIdentifierUniqueAttribute{
					AttributePath:  "UserName",
					AttributeValue: "ExampleUser",
				},
			},
			IdentityStoreId: example.IdentityStoreIds[0],
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("userId", exampleGetUser.UserId)
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

data "aws_ssoadmin_getinstances" "example" {
}
data "aws_identitystore_getuser" "exampleGetUser" {
  alternate_identifier = {
    unique_attribute = {
      attribute_path  = "UserName"
      attribute_value = "ExampleUser"
    }
  }
  identity_store_id = data.aws_ssoadmin_getinstances.example.identity_store_ids[0]
}

output "userId" {
  value = data.aws_identitystore_getuser.exampleGetUser.user_id
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.ssoadmin.SsoadminFunctions;
import com.pulumi.aws.ssoadmin.inputs.GetInstancesArgs;
import com.pulumi.aws.identitystore.IdentitystoreFunctions;
import com.pulumi.aws.identitystore.inputs.GetUserArgs;
import com.pulumi.aws.identitystore.inputs.GetUserAlternateIdentifierArgs;
import com.pulumi.aws.identitystore.inputs.GetUserAlternateIdentifierUniqueAttributeArgs;
import java.util.ArrayList;
import java.util.Arrays;
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 = SsoadminFunctions.getInstances(GetInstancesArgs.builder()
            .build());

        final var exampleGetUser = IdentitystoreFunctions.getUser(GetUserArgs.builder()
            .alternateIdentifier(GetUserAlternateIdentifierArgs.builder()
                .uniqueAttribute(GetUserAlternateIdentifierUniqueAttributeArgs.builder()
                    .attributePath("UserName")
                    .attributeValue("ExampleUser")
                    .build())
                .build())
            .identityStoreId(example.identityStoreIds()[0])
            .build());

        ctx.export("userId", exampleGetUser.userId());
    }
}
variables:
  example:
    fn::invoke:
      function: aws:ssoadmin:getInstances
      arguments: {}
  exampleGetUser:
    fn::invoke:
      function: aws:identitystore:getUser
      arguments:
        alternateIdentifier:
          uniqueAttribute:
            attributePath: UserName
            attributeValue: ExampleUser
        identityStoreId: ${example.identityStoreIds[0]}
outputs:
  userId: ${exampleGetUser.userId}

args Arguments passed to this invoke. Arguments for getUser. options Invoke options controlling this call.

Implementation

Future<GetUserResult> getUser(
  GetUserArgs args, {
  pulumi.InvokeOptions? options,
}) async {
  final deployment = pulumi.Deployment.instance;
  final result = await deployment.invoke<Map<String, dynamic>>(
    'aws:identitystore/getUser:getUser',
    args.toMap(),
    options: pulumi.toDeploymentInvokeOptions(options),
  );
  return GetUserResult.fromMap(result);
}