pulumi-keycloak-kotlin/com.pulumi.keycloak.ldap.kotlin/HardcodedGroupMapperArgs

HardcodedGroupMapperArgs

data class HardcodedGroupMapperArgs(val group: Output<String>? = null, val ldapUserFederationId: Output<String>? = null, val name: Output<String>? = null, val realmId: Output<String>? = null) : ConvertibleToJava<HardcodedGroupMapperArgs>

Allows for creating and managing hardcoded group mappers for Keycloak users federated via LDAP. The LDAP hardcoded group mapper will grant a specified Keycloak group to each Keycloak user linked with LDAP.

Example Usage

import * as pulumi from "@pulumi/pulumi";
import * as keycloak from "@pulumi/keycloak";
const realm = new keycloak.Realm("realm", {
    realm: "my-realm",
    enabled: true,
});
const ldapUserFederation = new keycloak.ldap.UserFederation("ldap_user_federation", {
    name: "openldap",
    realmId: realm.id,
    usernameLdapAttribute: "cn",
    rdnLdapAttribute: "cn",
    uuidLdapAttribute: "entryDN",
    userObjectClasses: [
        "simpleSecurityObject",
        "organizationalRole",
    ],
    connectionUrl: "ldap://openldap",
    usersDn: "dc=example,dc=org",
    bindDn: "cn=admin,dc=example,dc=org",
    bindCredential: "admin",
});
const realmGroup = new keycloak.Group("realm_group", {
    realmId: realm.id,
    name: "my-group",
});
const assignGroupToUsers = new keycloak.ldap.HardcodedGroupMapper("assign_group_to_users", {
    realmId: realm.id,
    ldapUserFederationId: ldapUserFederation.id,
    name: "assign-group-to-users",
    group: realmGroup.name,
});

import pulumi
import pulumi_keycloak as keycloak
realm = keycloak.Realm("realm",
    realm="my-realm",
    enabled=True)
ldap_user_federation = keycloak.ldap.UserFederation("ldap_user_federation",
    name="openldap",
    realm_id=realm.id,
    username_ldap_attribute="cn",
    rdn_ldap_attribute="cn",
    uuid_ldap_attribute="entryDN",
    user_object_classes=[
        "simpleSecurityObject",
        "organizationalRole",
    ],
    connection_url="ldap://openldap",
    users_dn="dc=example,dc=org",
    bind_dn="cn=admin,dc=example,dc=org",
    bind_credential="admin")
realm_group = keycloak.Group("realm_group",
    realm_id=realm.id,
    name="my-group")
assign_group_to_users = keycloak.ldap.HardcodedGroupMapper("assign_group_to_users",
    realm_id=realm.id,
    ldap_user_federation_id=ldap_user_federation.id,
    name="assign-group-to-users",
    group=realm_group.name)

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Keycloak = Pulumi.Keycloak;
return await Deployment.RunAsync(() =>
{
    var realm = new Keycloak.Realm("realm", new()
    {
        RealmName = "my-realm",
        Enabled = true,
    });
    var ldapUserFederation = new Keycloak.Ldap.UserFederation("ldap_user_federation", new()
    {
        Name = "openldap",
        RealmId = realm.Id,
        UsernameLdapAttribute = "cn",
        RdnLdapAttribute = "cn",
        UuidLdapAttribute = "entryDN",
        UserObjectClasses = new[]
        {
            "simpleSecurityObject",
            "organizationalRole",
        },
        ConnectionUrl = "ldap://openldap",
        UsersDn = "dc=example,dc=org",
        BindDn = "cn=admin,dc=example,dc=org",
        BindCredential = "admin",
    });
    var realmGroup = new Keycloak.Group("realm_group", new()
    {
        RealmId = realm.Id,
        Name = "my-group",
    });
    var assignGroupToUsers = new Keycloak.Ldap.HardcodedGroupMapper("assign_group_to_users", new()
    {
        RealmId = realm.Id,
        LdapUserFederationId = ldapUserFederation.Id,
        Name = "assign-group-to-users",
        Group = realmGroup.Name,
    });
});

package main
import (
	"github.com/pulumi/pulumi-keycloak/sdk/v5/go/keycloak"
	"github.com/pulumi/pulumi-keycloak/sdk/v5/go/keycloak/ldap"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		realm, err := keycloak.NewRealm(ctx, "realm", &keycloak.RealmArgs{
			Realm:   pulumi.String("my-realm"),
			Enabled: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		ldapUserFederation, err := ldap.NewUserFederation(ctx, "ldap_user_federation", &ldap.UserFederationArgs{
			Name:                  pulumi.String("openldap"),
			RealmId:               realm.ID(),
			UsernameLdapAttribute: pulumi.String("cn"),
			RdnLdapAttribute:      pulumi.String("cn"),
			UuidLdapAttribute:     pulumi.String("entryDN"),
			UserObjectClasses: pulumi.StringArray{
				pulumi.String("simpleSecurityObject"),
				pulumi.String("organizationalRole"),
			},
			ConnectionUrl:  pulumi.String("ldap://openldap"),
			UsersDn:        pulumi.String("dc=example,dc=org"),
			BindDn:         pulumi.String("cn=admin,dc=example,dc=org"),
			BindCredential: pulumi.String("admin"),
		})
		if err != nil {
			return err
		}
		realmGroup, err := keycloak.NewGroup(ctx, "realm_group", &keycloak.GroupArgs{
			RealmId: realm.ID(),
			Name:    pulumi.String("my-group"),
		})
		if err != nil {
			return err
		}
		_, err = ldap.NewHardcodedGroupMapper(ctx, "assign_group_to_users", &ldap.HardcodedGroupMapperArgs{
			RealmId:              realm.ID(),
			LdapUserFederationId: ldapUserFederation.ID(),
			Name:                 pulumi.String("assign-group-to-users"),
			Group:                realmGroup.Name,
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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.ldap.UserFederation;
import com.pulumi.keycloak.ldap.UserFederationArgs;
import com.pulumi.keycloak.Group;
import com.pulumi.keycloak.GroupArgs;
import com.pulumi.keycloak.ldap.HardcodedGroupMapper;
import com.pulumi.keycloak.ldap.HardcodedGroupMapperArgs;
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")
            .enabled(true)
            .build());
        var ldapUserFederation = new UserFederation("ldapUserFederation", UserFederationArgs.builder()
            .name("openldap")
            .realmId(realm.id())
            .usernameLdapAttribute("cn")
            .rdnLdapAttribute("cn")
            .uuidLdapAttribute("entryDN")
            .userObjectClasses(
                "simpleSecurityObject",
                "organizationalRole")
            .connectionUrl("ldap://openldap")
            .usersDn("dc=example,dc=org")
            .bindDn("cn=admin,dc=example,dc=org")
            .bindCredential("admin")
            .build());
        var realmGroup = new Group("realmGroup", GroupArgs.builder()
            .realmId(realm.id())
            .name("my-group")
            .build());
        var assignGroupToUsers = new HardcodedGroupMapper("assignGroupToUsers", HardcodedGroupMapperArgs.builder()
            .realmId(realm.id())
            .ldapUserFederationId(ldapUserFederation.id())
            .name("assign-group-to-users")
            .group(realmGroup.name())
            .build());
    }
}

resources:
  realm:
    type: keycloak:Realm
    properties:
      realm: my-realm
      enabled: true
  ldapUserFederation:
    type: keycloak:ldap:UserFederation
    name: ldap_user_federation
    properties:
      name: openldap
      realmId: ${realm.id}
      usernameLdapAttribute: cn
      rdnLdapAttribute: cn
      uuidLdapAttribute: entryDN
      userObjectClasses:
        - simpleSecurityObject
        - organizationalRole
      connectionUrl: ldap://openldap
      usersDn: dc=example,dc=org
      bindDn: cn=admin,dc=example,dc=org
      bindCredential: admin
  realmGroup:
    type: keycloak:Group
    name: realm_group
    properties:
      realmId: ${realm.id}
      name: my-group
  assignGroupToUsers:
    type: keycloak:ldap:HardcodedGroupMapper
    name: assign_group_to_users
    properties:
      realmId: ${realm.id}
      ldapUserFederationId: ${ldapUserFederation.id}
      name: assign-group-to-users
      group: ${realmGroup.name}

Import

LDAP mappers can be imported using the format {{realm_id}}/{{ldap_user_federation_id}}/{{ldap_mapper_id}}. The ID of the LDAP user federation provider and the mapper can be found within the Keycloak GUI, and they are typically GUIDs. Example: bash

$ pulumi import keycloak:ldap/hardcodedGroupMapper:HardcodedGroupMapper assign_group_to_users my-realm/af2a6ca3-e4d7-49c3-b08b-1b3c70b4b860/3d923ece-1a91-4bf7-adaf-3b82f2a12b67

Constructors

HardcodedGroupMapperArgs

constructor(group: Output<String>? = null, ldapUserFederationId: Output<String>? = null, name: Output<String>? = null, realmId: Output<String>? = null)

Properties

group

val group: Output<String>? = null

The name of the group which should be assigned to the users.

ldapUserFederationId

val ldapUserFederationId: Output<String>? = null

The ID of the LDAP user federation provider to attach this mapper to.

name

val name: Output<String>? = null

Display name of this mapper when displayed in the console.

realmId

val realmId: Output<String>? = null

The realm that this LDAP mapper will exist in.

Functions

toJava

open override fun toJava(): HardcodedGroupMapperArgs