keycloak.RealmUserProfile
Explore with Pulumi AI
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.
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=[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:
- Realm
Id string - The ID of the realm the user profile applies to.
- Attributes
List<Realm
User Profile Attribute> - An ordered list of attributes.
- Groups
List<Realm
User Profile Group> - A list of groups.
- Realm
Id string - The ID of the realm the user profile applies to.
- Attributes
[]Realm
User Profile Attribute Args - An ordered list of attributes.
- Groups
[]Realm
User Profile Group Args - A list of groups.
- realm
Id String - The ID of the realm the user profile applies to.
- attributes
List<Realm
User Profile Attribute> - An ordered list of attributes.
- groups
List<Realm
User Profile Group> - A list of groups.
- realm
Id string - The ID of the realm the user profile applies to.
- attributes
Realm
User Profile Attribute[] - An ordered list of attributes.
- groups
Realm
User Profile Group[] - A list of groups.
- realm_
id str - The ID of the realm the user profile applies to.
- attributes
Sequence[Realm
User Profile Attribute Args] - An ordered list of attributes.
- groups
Sequence[Realm
User Profile Group Args] - A list of groups.
- realm
Id 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.
- Attributes
List<Realm
User Profile Attribute> - An ordered list of attributes.
- Groups
List<Realm
User Profile Group> - A list of groups.
- Realm
Id string - The ID of the realm the user profile applies to.
- Attributes
[]Realm
User Profile Attribute Args - An ordered list of attributes.
- Groups
[]Realm
User Profile Group Args - A list of groups.
- Realm
Id string - The ID of the realm the user profile applies to.
- attributes
List<Realm
User Profile Attribute> - An ordered list of attributes.
- groups
List<Realm
User Profile Group> - A list of groups.
- realm
Id String - The ID of the realm the user profile applies to.
- attributes
Realm
User Profile Attribute[] - An ordered list of attributes.
- groups
Realm
User Profile Group[] - A list of groups.
- realm
Id string - The ID of the realm the user profile applies to.
- attributes
Sequence[Realm
User Profile Attribute Args] - An ordered list of attributes.
- groups
Sequence[Realm
User Profile Group Args] - 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.
- realm
Id String - The ID of the realm the user profile applies to.
Supporting Types
RealmUserProfileAttribute, RealmUserProfileAttributeArgs
- Name string
- Annotations Dictionary<string, string>
- Display
Name string - Enabled
When List<string>Scopes - Group string
- A list of groups.
- Permissions
Realm
User Profile Attribute Permissions - Required
For List<string>Roles - Required
For List<string>Scopes - Validators
List<Realm
User Profile Attribute Validator>
- Name string
- Annotations map[string]string
- Display
Name string - Enabled
When []stringScopes - Group string
- A list of groups.
- Permissions
Realm
User Profile Attribute Permissions - Required
For []stringRoles - Required
For []stringScopes - Validators
[]Realm
User Profile Attribute Validator
- name String
- annotations Map<String,String>
- display
Name String - enabled
When List<String>Scopes - group String
- A list of groups.
- permissions
Realm
User Profile Attribute Permissions - required
For List<String>Roles - required
For List<String>Scopes - validators
List<Realm
User Profile Attribute Validator>
- name string
- annotations {[key: string]: string}
- display
Name string - enabled
When string[]Scopes - group string
- A list of groups.
- permissions
Realm
User Profile Attribute Permissions - required
For string[]Roles - required
For string[]Scopes - validators
Realm
User Profile Attribute Validator[]
- name str
- annotations Mapping[str, str]
- display_
name str - enabled_
when_ Sequence[str]scopes - group str
- A list of groups.
- permissions
Realm
User Profile Attribute Permissions - required_
for_ Sequence[str]roles - required_
for_ Sequence[str]scopes - validators
Sequence[Realm
User Profile Attribute Validator]
- name String
- annotations Map<String>
- display
Name String - enabled
When List<String>Scopes - group String
- A list of groups.
- permissions Property Map
- required
For List<String>Roles - required
For List<String>Scopes - validators List<Property Map>
RealmUserProfileAttributePermissions, RealmUserProfileAttributePermissionsArgs
RealmUserProfileAttributeValidator, RealmUserProfileAttributeValidatorArgs
RealmUserProfileGroup, RealmUserProfileGroupArgs
- Name string
- Annotations Dictionary<string, string>
- Display
Description string - Display
Header string
- Name string
- Annotations map[string]string
- Display
Description string - Display
Header string
- name String
- annotations Map<String,String>
- display
Description String - display
Header String
- name string
- annotations {[key: string]: string}
- display
Description string - display
Header string
- name str
- annotations Mapping[str, str]
- display_
description str - display_
header str
- name String
- annotations Map<String>
- display
Description String - display
Header 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.