Groups versus roles
Periodically, I’m asked what the difference is between groups and roles. This is coming up even more frequently now that we’ve released version 11.0 of the Hitachi ID Identity and Access Management Suite, which includes full lifecycle management of groups (i.e., create, delete, update group objects on systems like AD).
This is actually a harder question to answer than one might think, because different systems and applications use the terms interchangeably. The object that I think of as a group might be called a group on one system (e.g., AD) and a role on another (e.g., SAP).
Ambiguous and overloaded terminology is very common in the IAM business, unfortunately.
Still, there’s a difference, once you define the two terms. To understand it, we should start with definitions. I’ll use Hitachi ID’s standard nomenclature here:
- A group is an object that exists on a target system (LDAP, AD, SAP, RAC/F, etc.). Accounts are attached to the group as members. The group is assigned security privileges. This way, it’s not necessary to assign individual access rights to each user — which would be painful for a variety of reasons.Note that this is an approximate definition. For example, on some systems, groups can contain other groups as members (AD, RAC/F come to mind). On other systems, groups are also used as mail distribution lists (AD, LDAP). In some cases, a group on one system can contain among its members accounts or groups from another system (AD with cross-domain groups, for example).
- A role is an object that exists on the IAM system. It’s used to collect entitlements (mainly groups, but also accounts) on target systems for more convenient assignment. Roles are typically nested — i.e., roles can contain other roles.Roles may be “technical” which just means that they represent collections of entitlements that are normally assigned together, but might not make much sense to business users, or they might be “organizational” which means that they represent business functions that requesters, authorizers or reviewers are more likely to understand. The difference here is a bit fuzzy, and that’s OK.
Beyond groups being on the target system and roles being in the IAM system, how are roles and groups different?
It turns out that how these objects are used in practice is quite different!
While IAM software vendors and implementation consultants strive to make role management a business-friendly task that managers will participate in, I’ve found that this rarely comes to pass. Managers rarely have the motivation, skills or time to participate meaningfully in defining or updating role definitions.
This has practical consequences: an IT team is ultimately responsible for defining and maintaining roles. They have limited visibility into business requirements and limited time to spend on any given role. These constraints make role definitions fairly static and formal.
Static, formal IAM roles usually wind up representing business functions (think job code). With static, formal roles it is natural to automatically assign roles: For example, birthright access for employees and contractors, departmental level roles for common access rights, job-code driven roles for jobs that are shared by large numbers of workers, etc. As HR systems or requests update identity attributes, the IAM system recalculates eligibility criteria and automatically assigns or revokes roles.
The consequence of all this is that roles are used to assign highly predictable, very regular access rights to users. If your location, department code, job code or cost centre can be used to predict your access rights and if your access rights are the same as many other people, then roles are the right tool to assign those rights to you, without extra manual intervention.
In practice, some access rights are simply hard to predict based on available data. For example, projects start up and wind down all the time. There is usually nothing in the HR database to indicate that a given user is involved in a project, so automation driven by HR data cannot grant or revoke project-related access rights.
This is part of a general pattern: automatic assignment of rights, via roles or not, only works well if we have both a sufficiently detailed, timely and reliable data source and a matching model that maps from identity attributes to entitlements.
Where this pattern ends is where directly assigned privileges begin. For directly assigned privileges, users could create new roles and request role assignment, but in practice users will skip the role definition step and just request the rights they want. i.e., users will request membership in the security groups that grant access to the share, folder or other item they wish to access, or ask to join a given mail distribution list.
There are two patterns for group membership management: groups may be included in roles, in which case they tend to be automatically assigned to appropriate users, or groups are not part of a role, in which case they tend to be requested on an as-needed basis.
Put another way: roles are formal and static, while groups may also be ad-hoc and dynamic.
What does ad-hoc mean?
- Ad-hoc groups won’t be automatically assigned, so users must be able to sign into a portal and find and request them.
- Users often don’t know what group to ask for (or even where to find the request portal), so significant usability support is required.
- Ad-hoc may also mean creating and deleting the groups themselves, rather than just just requesting membership.
- Anyone could request anything, so an approval workflow is required to prevent inappropriate requests from being completed.
- Nobody ever asks for access rights to be reduced, so a periodic access review and revocation process is essential.
And that’s it:
- Roles are IAM constructs used to build a formal model of predictable, static access rights that are usually automatically assigned,
- Groups are objects on existing systems and applications. They may either be parts of roles, or may be requested, approved, reviewed and revoked in an ad-hoc manner.