Docs Packages
  1. Packages
  2. Keycloak
  3. API Docs
  4. RealmUserProfile
Keycloak v5.3.2 published on Friday, May 10, 2024 by Pulumi
pulumi/pulumi-keycloak

keycloak.RealmUserProfile

Explore with Pulumi AI

keycloak logo
Keycloak v5.3.2 published on Friday, May 10, 2024 by Pulumi
pulumi/pulumi-keycloak

    Allows for managing Realm User Profiles within Keycloak.

    A user profile defines a schema for representing user attributes and how they are managed within a realm. This is a preview feature, hence not fully supported and disabled by default. To enable it, start the server with one of the following flags:

    • WildFly distribution: -Dkeycloak.profile.feature.declarative_user_profile=enabled
    • Quarkus distribution: --features=preview or --features=declarative-user-profile

    The realm linked to the keycloak.RealmUserProfile resource must have the user profile feature enabled. It can be done via the administration UI, or by setting the userProfileEnabled realm attribute to true.

    Example Usage

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

const realm = new keycloak.Realm("realm", {
    realm: "my-realm",
    attributes: {
        userProfileEnabled: true,
    },
});
const userprofile = new keycloak.RealmUserProfile("userprofile", {
    realmId: myRealm.id,
    attributes: [
        {
            name: "field1",
            displayName: "Field 1",
            group: "group1",
            enabledWhenScopes: ["offline_access"],
            requiredForRoles: ["user"],
            requiredForScopes: ["offline_access"],
            permissions: {
                views: [
                    "admin",
                    "user",
                ],
                edits: [
                    "admin",
                    "user",
                ],
            },
            validators: [
                {
                    name: "person-name-prohibited-characters",
                },
                {
                    name: "pattern",
                    config: {
                        pattern: "^[a-z]+$",
                        "error-message": "Nope",
                    },
                },
            ],
            annotations: {
                foo: "bar",
            },
        },
        {
            name: "field2",
            validators: [{
                name: "options",
                config: {
                    options: JSON.stringify(["opt1"]),
                },
            }],
            annotations: {
                foo: JSON.stringify({
                    key: "val",
                }),
            },
        },
    ],
    groups: [
        {
            name: "group1",
            displayHeader: "Group 1",
            displayDescription: "A first group",
            annotations: {
                foo: "bar",
                foo2: JSON.stringify({
                    key: "val",
                }),
            },
        },
        {
            name: "group2",
        },
    ],
});

    import pulumi
import json
import pulumi_keycloak as keycloak

realm = keycloak.Realm("realm",
    realm="my-realm",
    attributes={
        "userProfileEnabled": True,
    })
userprofile = keycloak.RealmUserProfile("userprofile",
    realm_id=my_realm["id"],
    attributes=[
        keycloak.RealmUserProfileAttributeArgs(
            name="field1",
            display_name="Field 1",
            group="group1",
            enabled_when_scopes=["offline_access"],
            required_for_roles=["user"],
            required_for_scopes=["offline_access"],
            permissions=keycloak.RealmUserProfileAttributePermissionsArgs(
                views=[
                    "admin",
                    "user",
                ],
                edits=[
                    "admin",
                    "user",
                ],
            ),
            validators=[
                keycloak.RealmUserProfileAttributeValidatorArgs(
                    name="person-name-prohibited-characters",
                ),
                keycloak.RealmUserProfileAttributeValidatorArgs(
                    name="pattern",
                    config={
                        "pattern": "^[a-z]+$",
                        "error-message": "Nope",
                    },
                ),
            ],
            annotations={
                "foo": "bar",
            },
        ),
        keycloak.RealmUserProfileAttributeArgs(
            name="field2",
            validators=[keycloak.RealmUserProfileAttributeValidatorArgs(
                name="options",
                config={
                    "options": json.dumps(["opt1"]),
                },
            )],
            annotations={
                "foo": json.dumps({
                    "key": "val",
                }),
            },
        ),
    ],
    groups=[
        keycloak.RealmUserProfileGroupArgs(
            name="group1",
            display_header="Group 1",
            display_description="A first group",
            annotations={
                "foo": "bar",
                "foo2": json.dumps({
                    "key": "val",
                }),
            },
        ),
        keycloak.RealmUserProfileGroupArgs(
            name="group2",
        ),
    ])

    package main

import (
	"encoding/json"

	"github.com/pulumi/pulumi-keycloak/sdk/v5/go/keycloak"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := keycloak.NewRealm(ctx, "realm", &keycloak.RealmArgs{
			Realm: pulumi.String("my-realm"),
			Attributes: pulumi.Map{
				"userProfileEnabled": pulumi.Any(true),
			},
		})
		if err != nil {
			return err
		}
		tmpJSON0, err := json.Marshal([]string{
			"opt1",
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		tmpJSON1, err := json.Marshal(map[string]interface{}{
			"key": "val",
		})
		if err != nil {
			return err
		}
		json1 := string(tmpJSON1)
		tmpJSON2, err := json.Marshal(map[string]interface{}{
			"key": "val",
		})
		if err != nil {
			return err
		}
		json2 := string(tmpJSON2)
		_, err = keycloak.NewRealmUserProfile(ctx, "userprofile", &keycloak.RealmUserProfileArgs{
			RealmId: pulumi.Any(myRealm.Id),
			Attributes: keycloak.RealmUserProfileAttributeArray{
				&keycloak.RealmUserProfileAttributeArgs{
					Name:        pulumi.String("field1"),
					DisplayName: pulumi.String("Field 1"),
					Group:       pulumi.String("group1"),
					EnabledWhenScopes: pulumi.StringArray{
						pulumi.String("offline_access"),
					},
					RequiredForRoles: pulumi.StringArray{
						pulumi.String("user"),
					},
					RequiredForScopes: pulumi.StringArray{
						pulumi.String("offline_access"),
					},
					Permissions: &keycloak.RealmUserProfileAttributePermissionsArgs{
						Views: pulumi.StringArray{
							pulumi.String("admin"),
							pulumi.String("user"),
						},
						Edits: pulumi.StringArray{
							pulumi.String("admin"),
							pulumi.String("user"),
						},
					},
					Validators: keycloak.RealmUserProfileAttributeValidatorArray{
						&keycloak.RealmUserProfileAttributeValidatorArgs{
							Name: pulumi.String("person-name-prohibited-characters"),
						},
						&keycloak.RealmUserProfileAttributeValidatorArgs{
							Name: pulumi.String("pattern"),
							Config: pulumi.StringMap{
								"pattern":       pulumi.String("^[a-z]+$"),
								"error-message": pulumi.String("Nope"),
							},
						},
					},
					Annotations: pulumi.StringMap{
						"foo": pulumi.String("bar"),
					},
				},
				&keycloak.RealmUserProfileAttributeArgs{
					Name: pulumi.String("field2"),
					Validators: keycloak.RealmUserProfileAttributeValidatorArray{
						&keycloak.RealmUserProfileAttributeValidatorArgs{
							Name: pulumi.String("options"),
							Config: pulumi.StringMap{
								"options": pulumi.String(json0),
							},
						},
					},
					Annotations: pulumi.StringMap{
						"foo": pulumi.String(json1),
					},
				},
			},
			Groups: keycloak.RealmUserProfileGroupArray{
				&keycloak.RealmUserProfileGroupArgs{
					Name:               pulumi.String("group1"),
					DisplayHeader:      pulumi.String("Group 1"),
					DisplayDescription: pulumi.String("A first group"),
					Annotations: pulumi.StringMap{
						"foo":  pulumi.String("bar"),
						"foo2": pulumi.String(json2),
					},
				},
				&keycloak.RealmUserProfileGroupArgs{
					Name: pulumi.String("group2"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

    using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using Pulumi;
using Keycloak = Pulumi.Keycloak;

return await Deployment.RunAsync(() => 
{
    var realm = new Keycloak.Realm("realm", new()
    {
        RealmName = "my-realm",
        Attributes = 
        {
            { "userProfileEnabled", true },
        },
    });

    var userprofile = new Keycloak.RealmUserProfile("userprofile", new()
    {
        RealmId = myRealm.Id,
        Attributes = new[]
        {
            new Keycloak.Inputs.RealmUserProfileAttributeArgs
            {
                Name = "field1",
                DisplayName = "Field 1",
                Group = "group1",
                EnabledWhenScopes = new[]
                {
                    "offline_access",
                },
                RequiredForRoles = new[]
                {
                    "user",
                },
                RequiredForScopes = new[]
                {
                    "offline_access",
                },
                Permissions = new Keycloak.Inputs.RealmUserProfileAttributePermissionsArgs
                {
                    Views = new[]
                    {
                        "admin",
                        "user",
                    },
                    Edits = new[]
                    {
                        "admin",
                        "user",
                    },
                },
                Validators = new[]
                {
                    new Keycloak.Inputs.RealmUserProfileAttributeValidatorArgs
                    {
                        Name = "person-name-prohibited-characters",
                    },
                    new Keycloak.Inputs.RealmUserProfileAttributeValidatorArgs
                    {
                        Name = "pattern",
                        Config = 
                        {
                            { "pattern", "^[a-z]+$" },
                            { "error-message", "Nope" },
                        },
                    },
                },
                Annotations = 
                {
                    { "foo", "bar" },
                },
            },
            new Keycloak.Inputs.RealmUserProfileAttributeArgs
            {
                Name = "field2",
                Validators = new[]
                {
                    new Keycloak.Inputs.RealmUserProfileAttributeValidatorArgs
                    {
                        Name = "options",
                        Config = 
                        {
                            { "options", JsonSerializer.Serialize(new[]
                            {
                                "opt1",
                            }) },
                        },
                    },
                },
                Annotations = 
                {
                    { "foo", JsonSerializer.Serialize(new Dictionary<string, object?>
                    {
                        ["key"] = "val",
                    }) },
                },
            },
        },
        Groups = new[]
        {
            new Keycloak.Inputs.RealmUserProfileGroupArgs
            {
                Name = "group1",
                DisplayHeader = "Group 1",
                DisplayDescription = "A first group",
                Annotations = 
                {
                    { "foo", "bar" },
                    { "foo2", JsonSerializer.Serialize(new Dictionary<string, object?>
                    {
                        ["key"] = "val",
                    }) },
                },
            },
            new Keycloak.Inputs.RealmUserProfileGroupArgs
            {
                Name = "group2",
            },
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.keycloak.Realm;
import com.pulumi.keycloak.RealmArgs;
import com.pulumi.keycloak.RealmUserProfile;
import com.pulumi.keycloak.RealmUserProfileArgs;
import com.pulumi.keycloak.inputs.RealmUserProfileAttributeArgs;
import com.pulumi.keycloak.inputs.RealmUserProfileAttributePermissionsArgs;
import com.pulumi.keycloak.inputs.RealmUserProfileGroupArgs;
import static com.pulumi.codegen.internal.Serialization.*;
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) {
        var realm = new Realm("realm", RealmArgs.builder()        
            .realm("my-realm")
            .attributes(Map.of("userProfileEnabled", true))
            .build());

        var userprofile = new RealmUserProfile("userprofile", RealmUserProfileArgs.builder()        
            .realmId(myRealm.id())
            .attributes(            
                RealmUserProfileAttributeArgs.builder()
                    .name("field1")
                    .displayName("Field 1")
                    .group("group1")
                    .enabledWhenScopes("offline_access")
                    .requiredForRoles("user")
                    .requiredForScopes("offline_access")
                    .permissions(RealmUserProfileAttributePermissionsArgs.builder()
                        .views(                        
                            "admin",
                            "user")
                        .edits(                        
                            "admin",
                            "user")
                        .build())
                    .validators(                    
                        RealmUserProfileAttributeValidatorArgs.builder()
                            .name("person-name-prohibited-characters")
                            .build(),
                        RealmUserProfileAttributeValidatorArgs.builder()
                            .name("pattern")
                            .config(Map.ofEntries(
                                Map.entry("pattern", "^[a-z]+$"),
                                Map.entry("error-message", "Nope")
                            ))
                            .build())
                    .annotations(Map.of("foo", "bar"))
                    .build(),
                RealmUserProfileAttributeArgs.builder()
                    .name("field2")
                    .validators(RealmUserProfileAttributeValidatorArgs.builder()
                        .name("options")
                        .config(Map.of("options", serializeJson(
                            jsonArray("opt1"))))
                        .build())
                    .annotations(Map.of("foo", serializeJson(
                        jsonObject(
                            jsonProperty("key", "val")
                        ))))
                    .build())
            .groups(            
                RealmUserProfileGroupArgs.builder()
                    .name("group1")
                    .displayHeader("Group 1")
                    .displayDescription("A first group")
                    .annotations(Map.ofEntries(
                        Map.entry("foo", "bar"),
                        Map.entry("foo2", serializeJson(
                            jsonObject(
                                jsonProperty("key", "val")
                            )))
                    ))
                    .build(),
                RealmUserProfileGroupArgs.builder()
                    .name("group2")
                    .build())
            .build());

    }
}

    resources:
  realm:
    type: keycloak:Realm
    properties:
      realm: my-realm
      attributes:
        userProfileEnabled: true
  userprofile:
    type: keycloak:RealmUserProfile
    properties:
      realmId: ${myRealm.id}
      attributes:
        - name: field1
          displayName: Field 1
          group: group1
          enabledWhenScopes:
            - offline_access
          requiredForRoles:
            - user
          requiredForScopes:
            - offline_access
          permissions:
            views:
              - admin
              - user
            edits:
              - admin
              - user
          validators:
            - name: person-name-prohibited-characters
            - name: pattern
              config:
                pattern: ^[a-z]+$
                error-message: Nope
          annotations:
            foo: bar
        - name: field2
          validators:
            - name: options
              config:
                options:
                  fn::toJSON:
                    - opt1
          annotations:
            foo:
              fn::toJSON:
                key: val
      groups:
        - name: group1
          displayHeader: Group 1
          displayDescription: A first group
          annotations:
            foo: bar
            foo2:
              fn::toJSON:
                key: val
        - name: group2

    Create RealmUserProfile Resource

    Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

    Constructor syntax

    new RealmUserProfile(name: string, args: RealmUserProfileArgs, opts?: CustomResourceOptions);
    @overload
def RealmUserProfile(resource_name: str,
                     args: RealmUserProfileArgs,
                     opts: Optional[ResourceOptions] = None)

@overload
def RealmUserProfile(resource_name: str,
                     opts: Optional[ResourceOptions] = None,
                     realm_id: Optional[str] = None,
                     attributes: Optional[Sequence[RealmUserProfileAttributeArgs]] = None,
                     groups: Optional[Sequence[RealmUserProfileGroupArgs]] = None)
    func NewRealmUserProfile(ctx *Context, name string, args RealmUserProfileArgs, opts ...ResourceOption) (*RealmUserProfile, error)
    public RealmUserProfile(string name, RealmUserProfileArgs args, CustomResourceOptions? opts = null)
    public RealmUserProfile(String name, RealmUserProfileArgs args)
public RealmUserProfile(String name, RealmUserProfileArgs args, CustomResourceOptions options)

    type: keycloak:RealmUserProfile
properties: # The arguments to resource properties.
options: # Bag of options to control resource's behavior.

    Parameters

    name string
    The unique name of the resource.
    args RealmUserProfileArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    resource_name str
    The unique name of the resource.
    args RealmUserProfileArgs
    The arguments to resource properties.
    opts ResourceOptions
    Bag of options to control resource's behavior.
    ctx Context
    Context object for the current deployment.
    name string
    The unique name of the resource.
    args RealmUserProfileArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args RealmUserProfileArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args RealmUserProfileArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    Example

    The following reference example uses placeholder values for all input properties.

    var realmUserProfileResource = new Keycloak.RealmUserProfile("realmUserProfileResource", new()
{
    RealmId = "string",
    Attributes = new[]
    {
        new Keycloak.Inputs.RealmUserProfileAttributeArgs
        {
            Name = "string",
            Annotations = 
            {
                { "string", "string" },
            },
            DisplayName = "string",
            EnabledWhenScopes = new[]
            {
                "string",
            },
            Group = "string",
            Permissions = new Keycloak.Inputs.RealmUserProfileAttributePermissionsArgs
            {
                Edits = new[]
                {
                    "string",
                },
                Views = new[]
                {
                    "string",
                },
            },
            RequiredForRoles = new[]
            {
                "string",
            },
            RequiredForScopes = new[]
            {
                "string",
            },
            Validators = new[]
            {
                new Keycloak.Inputs.RealmUserProfileAttributeValidatorArgs
                {
                    Name = "string",
                    Config = 
                    {
                        { "string", "string" },
                    },
                },
            },
        },
    },
    Groups = new[]
    {
        new Keycloak.Inputs.RealmUserProfileGroupArgs
        {
            Name = "string",
            Annotations = 
            {
                { "string", "string" },
            },
            DisplayDescription = "string",
            DisplayHeader = "string",
        },
    },
});

    example, err := keycloak.NewRealmUserProfile(ctx, "realmUserProfileResource", &keycloak.RealmUserProfileArgs{
	RealmId: pulumi.String("string"),
	Attributes: keycloak.RealmUserProfileAttributeArray{
		&keycloak.RealmUserProfileAttributeArgs{
			Name: pulumi.String("string"),
			Annotations: pulumi.StringMap{
				"string": pulumi.String("string"),
			},
			DisplayName: pulumi.String("string"),
			EnabledWhenScopes: pulumi.StringArray{
				pulumi.String("string"),
			},
			Group: pulumi.String("string"),
			Permissions: &keycloak.RealmUserProfileAttributePermissionsArgs{
				Edits: pulumi.StringArray{
					pulumi.String("string"),
				},
				Views: pulumi.StringArray{
					pulumi.String("string"),
				},
			},
			RequiredForRoles: pulumi.StringArray{
				pulumi.String("string"),
			},
			RequiredForScopes: pulumi.StringArray{
				pulumi.String("string"),
			},
			Validators: keycloak.RealmUserProfileAttributeValidatorArray{
				&keycloak.RealmUserProfileAttributeValidatorArgs{
					Name: pulumi.String("string"),
					Config: pulumi.StringMap{
						"string": pulumi.String("string"),
					},
				},
			},
		},
	},
	Groups: keycloak.RealmUserProfileGroupArray{
		&keycloak.RealmUserProfileGroupArgs{
			Name: pulumi.String("string"),
			Annotations: pulumi.StringMap{
				"string": pulumi.String("string"),
			},
			DisplayDescription: pulumi.String("string"),
			DisplayHeader:      pulumi.String("string"),
		},
	},
})

    var realmUserProfileResource = new RealmUserProfile("realmUserProfileResource", RealmUserProfileArgs.builder()
    .realmId("string")
    .attributes(RealmUserProfileAttributeArgs.builder()
        .name("string")
        .annotations(Map.of("string", "string"))
        .displayName("string")
        .enabledWhenScopes("string")
        .group("string")
        .permissions(RealmUserProfileAttributePermissionsArgs.builder()
            .edits("string")
            .views("string")
            .build())
        .requiredForRoles("string")
        .requiredForScopes("string")
        .validators(RealmUserProfileAttributeValidatorArgs.builder()
            .name("string")
            .config(Map.of("string", "string"))
            .build())
        .build())
    .groups(RealmUserProfileGroupArgs.builder()
        .name("string")
        .annotations(Map.of("string", "string"))
        .displayDescription("string")
        .displayHeader("string")
        .build())
    .build());

    realm_user_profile_resource = keycloak.RealmUserProfile("realmUserProfileResource",
    realm_id="string",
    attributes=[keycloak.RealmUserProfileAttributeArgs(
        name="string",
        annotations={
            "string": "string",
        },
        display_name="string",
        enabled_when_scopes=["string"],
        group="string",
        permissions=keycloak.RealmUserProfileAttributePermissionsArgs(
            edits=["string"],
            views=["string"],
        ),
        required_for_roles=["string"],
        required_for_scopes=["string"],
        validators=[keycloak.RealmUserProfileAttributeValidatorArgs(
            name="string",
            config={
                "string": "string",
            },
        )],
    )],
    groups=[keycloak.RealmUserProfileGroupArgs(
        name="string",
        annotations={
            "string": "string",
        },
        display_description="string",
        display_header="string",
    )])

    const realmUserProfileResource = new keycloak.RealmUserProfile("realmUserProfileResource", {
    realmId: "string",
    attributes: [{
        name: "string",
        annotations: {
            string: "string",
        },
        displayName: "string",
        enabledWhenScopes: ["string"],
        group: "string",
        permissions: {
            edits: ["string"],
            views: ["string"],
        },
        requiredForRoles: ["string"],
        requiredForScopes: ["string"],
        validators: [{
            name: "string",
            config: {
                string: "string",
            },
        }],
    }],
    groups: [{
        name: "string",
        annotations: {
            string: "string",
        },
        displayDescription: "string",
        displayHeader: "string",
    }],
});

    type: keycloak:RealmUserProfile
properties:
    attributes:
        - annotations:
            string: string
          displayName: string
          enabledWhenScopes:
            - string
          group: string
          name: string
          permissions:
            edits:
                - string
            views:
                - string
          requiredForRoles:
            - string
          requiredForScopes:
            - string
          validators:
            - config:
                string: string
              name: string
    groups:
        - annotations:
            string: string
          displayDescription: string
          displayHeader: string
          name: string
    realmId: string

    RealmUserProfile Resource Properties

    To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

    Inputs

    The RealmUserProfile resource accepts the following input properties:

    RealmId string
    The ID of the realm the user profile applies to.
    Attributes List<RealmUserProfileAttribute>
    An ordered list of attributes.
    Groups List<RealmUserProfileGroup>
    A list of groups.
    RealmId string
    The ID of the realm the user profile applies to.
    Attributes []RealmUserProfileAttributeArgs
    An ordered list of attributes.
    Groups []RealmUserProfileGroupArgs
    A list of groups.
    realmId String
    The ID of the realm the user profile applies to.
    attributes List<RealmUserProfileAttribute>
    An ordered list of attributes.
    groups List<RealmUserProfileGroup>
    A list of groups.
    realmId string
    The ID of the realm the user profile applies to.
    attributes RealmUserProfileAttribute[]
    An ordered list of attributes.
    groups RealmUserProfileGroup[]
    A list of groups.
    realm_id str
    The ID of the realm the user profile applies to.
    attributes Sequence[RealmUserProfileAttributeArgs]
    An ordered list of attributes.
    groups Sequence[RealmUserProfileGroupArgs]
    A list of groups.
    realmId String
    The ID of the realm the user profile applies to.
    attributes List<Property Map>
    An ordered list of attributes.
    groups List<Property Map>
    A list of groups.

    Outputs

    All input properties are implicitly available as output properties. Additionally, the RealmUserProfile resource produces the following output properties:

    Id string
    The provider-assigned unique ID for this managed resource.
    Id string
    The provider-assigned unique ID for this managed resource.
    id String
    The provider-assigned unique ID for this managed resource.
    id string
    The provider-assigned unique ID for this managed resource.
    id str
    The provider-assigned unique ID for this managed resource.
    id String
    The provider-assigned unique ID for this managed resource.

    Look up Existing RealmUserProfile Resource

    Get an existing RealmUserProfile resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

    public static get(name: string, id: Input<ID>, state?: RealmUserProfileState, opts?: CustomResourceOptions): RealmUserProfile
    @staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        attributes: Optional[Sequence[RealmUserProfileAttributeArgs]] = None,
        groups: Optional[Sequence[RealmUserProfileGroupArgs]] = None,
        realm_id: Optional[str] = None) -> RealmUserProfile
    func GetRealmUserProfile(ctx *Context, name string, id IDInput, state *RealmUserProfileState, opts ...ResourceOption) (*RealmUserProfile, error)
    public static RealmUserProfile Get(string name, Input<string> id, RealmUserProfileState? state, CustomResourceOptions? opts = null)
    public static RealmUserProfile get(String name, Output<String> id, RealmUserProfileState state, CustomResourceOptions options)
    Resource lookup is not supported in YAML
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    resource_name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    The following state arguments are supported:
    Attributes List<RealmUserProfileAttribute>
    An ordered list of attributes.
    Groups List<RealmUserProfileGroup>
    A list of groups.
    RealmId string
    The ID of the realm the user profile applies to.
    Attributes []RealmUserProfileAttributeArgs
    An ordered list of attributes.
    Groups []RealmUserProfileGroupArgs
    A list of groups.
    RealmId string
    The ID of the realm the user profile applies to.
    attributes List<RealmUserProfileAttribute>
    An ordered list of attributes.
    groups List<RealmUserProfileGroup>
    A list of groups.
    realmId String
    The ID of the realm the user profile applies to.
    attributes RealmUserProfileAttribute[]
    An ordered list of attributes.
    groups RealmUserProfileGroup[]
    A list of groups.
    realmId string
    The ID of the realm the user profile applies to.
    attributes Sequence[RealmUserProfileAttributeArgs]
    An ordered list of attributes.
    groups Sequence[RealmUserProfileGroupArgs]
    A list of groups.
    realm_id str
    The ID of the realm the user profile applies to.
    attributes List<Property Map>
    An ordered list of attributes.
    groups List<Property Map>
    A list of groups.
    realmId String
    The ID of the realm the user profile applies to.

    Supporting Types

    RealmUserProfileAttribute, RealmUserProfileAttributeArgs

    name String
    annotations Map<String>
    displayName String
    enabledWhenScopes List<String>
    group String
    A list of groups.
    permissions Property Map
    requiredForRoles List<String>
    requiredForScopes List<String>
    validators List<Property Map>

    RealmUserProfileAttributePermissions, RealmUserProfileAttributePermissionsArgs

    Edits List<string>
    Views List<string>
    Edits []string
    Views []string
    edits List<String>
    views List<String>
    edits string[]
    views string[]
    edits Sequence[str]
    views Sequence[str]
    edits List<String>
    views List<String>

    RealmUserProfileAttributeValidator, RealmUserProfileAttributeValidatorArgs

    Name string
    Config Dictionary<string, string>
    Name string
    Config map[string]string
    name String
    config Map<String,String>
    name string
    config {[key: string]: string}
    name str
    config Mapping[str, str]
    name String
    config Map<String>

    RealmUserProfileGroup, RealmUserProfileGroupArgs

    Name string
    Annotations Dictionary<string, string>
    DisplayDescription string
    DisplayHeader string
    Name string
    Annotations map[string]string
    DisplayDescription string
    DisplayHeader string
    name String
    annotations Map<String,String>
    displayDescription String
    displayHeader String
    name string
    annotations {[key: string]: string}
    displayDescription string
    displayHeader string
    name String
    annotations Map<String>
    displayDescription String
    displayHeader String

    Import

    This resource currently does not support importing.

    To learn more about importing existing cloud resources, see Importing resources.

    Package Details

    Repository
    Keycloak pulumi/pulumi-keycloak
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the keycloak Terraform Provider.
    keycloak logo
    Keycloak v5.3.2 published on Friday, May 10, 2024 by Pulumi
    pulumi/pulumi-keycloak