Docs Home Pulumi IaC Pulumi ESC Pulumi Cloud Packages Tutorials
  1. Packages
  2. Keycloak Provider
  3. API Docs
  4. RealmUserProfile
Keycloak v5.3.5 published on Wednesday, Oct 16, 2024 by Pulumi
pulumi/pulumi-keycloak

keycloak.RealmUserProfile

Explore with Pulumi AI

keycloak logo
Keycloak v5.3.5 published on Wednesday, Oct 16, 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=[
        {
            "name": "field1",
            "display_name": "Field 1",
            "group": "group1",
            "enabled_when_scopes": ["offline_access"],
            "required_for_roles": ["user"],
            "required_for_scopes": ["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.dumps(["opt1"]),
                },
            }],
            "annotations": {
                "foo": json.dumps({
                    "key": "val",
                }),
            },
        },
    ],
    groups=[
        {
            "name": "group1",
            "display_header": "Group 1",
            "display_description": "A first group",
            "annotations": {
                "foo": "bar",
                "foo2": json.dumps({
                    "key": "val",
                }),
            },
        },
        {
            "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.StringMap{
				"userProfileEnabled": pulumi.String("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.

    Constructor 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=[{
        "name": "string",
        "annotations": {
            "string": "string",
        },
        "display_name": "string",
        "enabled_when_scopes": ["string"],
        "group": "string",
        "permissions": {
            "edits": ["string"],
            "views": ["string"],
        },
        "required_for_roles": ["string"],
        "required_for_scopes": ["string"],
        "validators": [{
            "name": "string",
            "config": {
                "string": "string",
            },
        }],
    }],
    groups=[{
        "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

    In Python, inputs that are objects can be passed either as argument classes or as dictionary literals.

    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 Dictionary<string, string>
    DisplayName string
    The display name of the attribute.
    EnabledWhenScopes List<string>
    A list of scopes. The attribute will only be enabled when these scopes are requested by clients.
    Group string
    A list of groups.
    Permissions RealmUserProfileAttributePermissions
    The permissions configuration information.
    RequiredForRoles List<string>
    A list of roles for which the attribute will be required.
    RequiredForScopes List<string>
    A list of scopes for which the attribute will be required.
    Validators List<RealmUserProfileAttributeValidator>
    A list of validators for the attribute.
    Name string
    Annotations map[string]string
    DisplayName string
    The display name of the attribute.
    EnabledWhenScopes []string
    A list of scopes. The attribute will only be enabled when these scopes are requested by clients.
    Group string
    A list of groups.
    Permissions RealmUserProfileAttributePermissions
    The permissions configuration information.
    RequiredForRoles []string
    A list of roles for which the attribute will be required.
    RequiredForScopes []string
    A list of scopes for which the attribute will be required.
    Validators []RealmUserProfileAttributeValidator
    A list of validators for the attribute.
    name String
    annotations Map<String,String>
    displayName String
    The display name of the attribute.
    enabledWhenScopes List<String>
    A list of scopes. The attribute will only be enabled when these scopes are requested by clients.
    group String
    A list of groups.
    permissions RealmUserProfileAttributePermissions
    The permissions configuration information.
    requiredForRoles List<String>
    A list of roles for which the attribute will be required.
    requiredForScopes List<String>
    A list of scopes for which the attribute will be required.
    validators List<RealmUserProfileAttributeValidator>
    A list of validators for the attribute.
    name string
    annotations {[key: string]: string}
    displayName string
    The display name of the attribute.
    enabledWhenScopes string[]
    A list of scopes. The attribute will only be enabled when these scopes are requested by clients.
    group string
    A list of groups.
    permissions RealmUserProfileAttributePermissions
    The permissions configuration information.
    requiredForRoles string[]
    A list of roles for which the attribute will be required.
    requiredForScopes string[]
    A list of scopes for which the attribute will be required.
    validators RealmUserProfileAttributeValidator[]
    A list of validators for the attribute.
    name str
    annotations Mapping[str, str]
    display_name str
    The display name of the attribute.
    enabled_when_scopes Sequence[str]
    A list of scopes. The attribute will only be enabled when these scopes are requested by clients.
    group str
    A list of groups.
    permissions RealmUserProfileAttributePermissions
    The permissions configuration information.
    required_for_roles Sequence[str]
    A list of roles for which the attribute will be required.
    required_for_scopes Sequence[str]
    A list of scopes for which the attribute will be required.
    validators Sequence[RealmUserProfileAttributeValidator]
    A list of validators for the attribute.
    name String
    annotations Map<String>
    displayName String
    The display name of the attribute.
    enabledWhenScopes List<String>
    A list of scopes. The attribute will only be enabled when these scopes are requested by clients.
    group String
    A list of groups.
    permissions Property Map
    The permissions configuration information.
    requiredForRoles List<String>
    A list of roles for which the attribute will be required.
    requiredForScopes List<String>
    A list of scopes for which the attribute will be required.
    validators List<Property Map>
    A list of validators for the attribute.

    RealmUserProfileAttributePermissions, RealmUserProfileAttributePermissionsArgs

    Edits List<string>
    A list of profiles that will be able to edit the attribute. One of admin, user.
    Views List<string>
    A list of profiles that will be able to view the attribute. One of admin, user.
    Edits []string
    A list of profiles that will be able to edit the attribute. One of admin, user.
    Views []string
    A list of profiles that will be able to view the attribute. One of admin, user.
    edits List<String>
    A list of profiles that will be able to edit the attribute. One of admin, user.
    views List<String>
    A list of profiles that will be able to view the attribute. One of admin, user.
    edits string[]
    A list of profiles that will be able to edit the attribute. One of admin, user.
    views string[]
    A list of profiles that will be able to view the attribute. One of admin, user.
    edits Sequence[str]
    A list of profiles that will be able to edit the attribute. One of admin, user.
    views Sequence[str]
    A list of profiles that will be able to view the attribute. One of admin, user.
    edits List<String>
    A list of profiles that will be able to edit the attribute. One of admin, user.
    views List<String>
    A list of profiles that will be able to view the attribute. One of admin, user.

    RealmUserProfileAttributeValidator, RealmUserProfileAttributeValidatorArgs

    Name string
    Config Dictionary<string, string>
    A map defining the configuration of the validator. Values can be a String or a json object.
    Name string
    Config map[string]string
    A map defining the configuration of the validator. Values can be a String or a json object.
    name String
    config Map<String,String>
    A map defining the configuration of the validator. Values can be a String or a json object.
    name string
    config {[key: string]: string}
    A map defining the configuration of the validator. Values can be a String or a json object.
    name str
    config Mapping[str, str]
    A map defining the configuration of the validator. Values can be a String or a json object.
    name String
    config Map<String>
    A map defining the configuration of the validator. Values can be a String or a json object.

    RealmUserProfileGroup, RealmUserProfileGroupArgs

    Name string
    Annotations Dictionary<string, string>
    DisplayDescription string
    The display description of the group.
    DisplayHeader string
    The display header of the group.
    Name string
    Annotations map[string]string
    DisplayDescription string
    The display description of the group.
    DisplayHeader string
    The display header of the group.
    name String
    annotations Map<String,String>
    displayDescription String
    The display description of the group.
    displayHeader String
    The display header of the group.
    name string
    annotations {[key: string]: string}
    displayDescription string
    The display description of the group.
    displayHeader string
    The display header of the group.
    name str
    annotations Mapping[str, str]
    display_description str
    The display description of the group.
    display_header str
    The display header of the group.
    name String
    annotations Map<String>
    displayDescription String
    The display description of the group.
    displayHeader String
    The display header of the group.

    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.5 published on Wednesday, Oct 16, 2024 by Pulumi
    pulumi/pulumi-keycloak