Manage GCP Dataplex Glossary IAM Access

The gcp:dataplex/glossaryIamMember:GlossaryIamMember resource, part of the Pulumi GCP provider, grants IAM roles to individual members on Dataplex glossaries without affecting other members or roles. This guide focuses on three capabilities: non-authoritative single-member grants, role-level member management, and complete policy replacement.

GCP provides three related resources for glossary IAM management. GlossaryIamMember adds one member to a role non-authoritatively. GlossaryIamBinding manages all members for a role authoritatively. GlossaryIamPolicy replaces the entire IAM policy. GlossaryIamPolicy cannot be used with the other two resources; they will conflict. GlossaryIamBinding and GlossaryIamMember can coexist if they manage different roles. The examples are intentionally small. Combine them with your own glossary resources and member identities.

Grant a role to a single member

Most IAM configurations add one user or service account to a role, preserving other members who already have that role.

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

const member = new gcp.dataplex.GlossaryIamMember("member", {
    project: glossaryTestId.project,
    location: glossaryTestId.location,
    glossaryId: glossaryTestId.glossaryId,
    role: "roles/viewer",
    member: "user:jane@example.com",
});

import pulumi
import pulumi_gcp as gcp

member = gcp.dataplex.GlossaryIamMember("member",
    project=glossary_test_id["project"],
    location=glossary_test_id["location"],
    glossary_id=glossary_test_id["glossaryId"],
    role="roles/viewer",
    member="user:jane@example.com")

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/dataplex"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := dataplex.NewGlossaryIamMember(ctx, "member", &dataplex.GlossaryIamMemberArgs{
			Project:    pulumi.Any(glossaryTestId.Project),
			Location:   pulumi.Any(glossaryTestId.Location),
			GlossaryId: pulumi.Any(glossaryTestId.GlossaryId),
			Role:       pulumi.String("roles/viewer"),
			Member:     pulumi.String("user:jane@example.com"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;

return await Deployment.RunAsync(() => 
{
    var member = new Gcp.DataPlex.GlossaryIamMember("member", new()
    {
        Project = glossaryTestId.Project,
        Location = glossaryTestId.Location,
        GlossaryId = glossaryTestId.GlossaryId,
        Role = "roles/viewer",
        Member = "user:jane@example.com",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.dataplex.GlossaryIamMember;
import com.pulumi.gcp.dataplex.GlossaryIamMemberArgs;
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 member = new GlossaryIamMember("member", GlossaryIamMemberArgs.builder()
            .project(glossaryTestId.project())
            .location(glossaryTestId.location())
            .glossaryId(glossaryTestId.glossaryId())
            .role("roles/viewer")
            .member("user:jane@example.com")
            .build());

    }
}

resources:
  member:
    type: gcp:dataplex:GlossaryIamMember
    properties:
      project: ${glossaryTestId.project}
      location: ${glossaryTestId.location}
      glossaryId: ${glossaryTestId.glossaryId}
      role: roles/viewer
      member: user:jane@example.com

The member property specifies the identity receiving access, using formats like “user:jane@example.com” or “serviceAccount:app@project.iam.gserviceaccount.com”. The role property defines the permission level. This resource is non-authoritative: it adds the member without removing others who already have the role.

Grant a role to multiple members at once

When several users need the same role, GlossaryIamBinding manages the complete member list in one resource.

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

const binding = new gcp.dataplex.GlossaryIamBinding("binding", {
    project: glossaryTestId.project,
    location: glossaryTestId.location,
    glossaryId: glossaryTestId.glossaryId,
    role: "roles/viewer",
    members: ["user:jane@example.com"],
});

import pulumi
import pulumi_gcp as gcp

binding = gcp.dataplex.GlossaryIamBinding("binding",
    project=glossary_test_id["project"],
    location=glossary_test_id["location"],
    glossary_id=glossary_test_id["glossaryId"],
    role="roles/viewer",
    members=["user:jane@example.com"])

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/dataplex"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := dataplex.NewGlossaryIamBinding(ctx, "binding", &dataplex.GlossaryIamBindingArgs{
			Project:    pulumi.Any(glossaryTestId.Project),
			Location:   pulumi.Any(glossaryTestId.Location),
			GlossaryId: pulumi.Any(glossaryTestId.GlossaryId),
			Role:       pulumi.String("roles/viewer"),
			Members: pulumi.StringArray{
				pulumi.String("user:jane@example.com"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;

return await Deployment.RunAsync(() => 
{
    var binding = new Gcp.DataPlex.GlossaryIamBinding("binding", new()
    {
        Project = glossaryTestId.Project,
        Location = glossaryTestId.Location,
        GlossaryId = glossaryTestId.GlossaryId,
        Role = "roles/viewer",
        Members = new[]
        {
            "user:jane@example.com",
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.dataplex.GlossaryIamBinding;
import com.pulumi.gcp.dataplex.GlossaryIamBindingArgs;
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 binding = new GlossaryIamBinding("binding", GlossaryIamBindingArgs.builder()
            .project(glossaryTestId.project())
            .location(glossaryTestId.location())
            .glossaryId(glossaryTestId.glossaryId())
            .role("roles/viewer")
            .members("user:jane@example.com")
            .build());

    }
}

resources:
  binding:
    type: gcp:dataplex:GlossaryIamBinding
    properties:
      project: ${glossaryTestId.project}
      location: ${glossaryTestId.location}
      glossaryId: ${glossaryTestId.glossaryId}
      role: roles/viewer
      members:
        - user:jane@example.com

The members property lists all identities that should have the role. This resource is authoritative for the specified role: it replaces the member list for that role but preserves other roles in the policy. If another GlossaryIamBinding or GlossaryIamMember manages the same role, they will conflict.

Replace the entire IAM policy

Organizations with strict access control sometimes define the complete IAM policy from scratch.

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

const admin = gcp.organizations.getIAMPolicy({
    bindings: [{
        role: "roles/viewer",
        members: ["user:jane@example.com"],
    }],
});
const policy = new gcp.dataplex.GlossaryIamPolicy("policy", {
    project: glossaryTestId.project,
    location: glossaryTestId.location,
    glossaryId: glossaryTestId.glossaryId,
    policyData: admin.then(admin => admin.policyData),
});

import pulumi
import pulumi_gcp as gcp

admin = gcp.organizations.get_iam_policy(bindings=[{
    "role": "roles/viewer",
    "members": ["user:jane@example.com"],
}])
policy = gcp.dataplex.GlossaryIamPolicy("policy",
    project=glossary_test_id["project"],
    location=glossary_test_id["location"],
    glossary_id=glossary_test_id["glossaryId"],
    policy_data=admin.policy_data)

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/dataplex"
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/organizations"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		admin, err := organizations.LookupIAMPolicy(ctx, &organizations.LookupIAMPolicyArgs{
			Bindings: []organizations.GetIAMPolicyBinding{
				{
					Role: "roles/viewer",
					Members: []string{
						"user:jane@example.com",
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		_, err = dataplex.NewGlossaryIamPolicy(ctx, "policy", &dataplex.GlossaryIamPolicyArgs{
			Project:    pulumi.Any(glossaryTestId.Project),
			Location:   pulumi.Any(glossaryTestId.Location),
			GlossaryId: pulumi.Any(glossaryTestId.GlossaryId),
			PolicyData: pulumi.String(admin.PolicyData),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;

return await Deployment.RunAsync(() => 
{
    var admin = Gcp.Organizations.GetIAMPolicy.Invoke(new()
    {
        Bindings = new[]
        {
            new Gcp.Organizations.Inputs.GetIAMPolicyBindingInputArgs
            {
                Role = "roles/viewer",
                Members = new[]
                {
                    "user:jane@example.com",
                },
            },
        },
    });

    var policy = new Gcp.DataPlex.GlossaryIamPolicy("policy", new()
    {
        Project = glossaryTestId.Project,
        Location = glossaryTestId.Location,
        GlossaryId = glossaryTestId.GlossaryId,
        PolicyData = admin.Apply(getIAMPolicyResult => getIAMPolicyResult.PolicyData),
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.organizations.OrganizationsFunctions;
import com.pulumi.gcp.organizations.inputs.GetIAMPolicyArgs;
import com.pulumi.gcp.dataplex.GlossaryIamPolicy;
import com.pulumi.gcp.dataplex.GlossaryIamPolicyArgs;
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) {
        final var admin = OrganizationsFunctions.getIAMPolicy(GetIAMPolicyArgs.builder()
            .bindings(GetIAMPolicyBindingArgs.builder()
                .role("roles/viewer")
                .members("user:jane@example.com")
                .build())
            .build());

        var policy = new GlossaryIamPolicy("policy", GlossaryIamPolicyArgs.builder()
            .project(glossaryTestId.project())
            .location(glossaryTestId.location())
            .glossaryId(glossaryTestId.glossaryId())
            .policyData(admin.policyData())
            .build());

    }
}

resources:
  policy:
    type: gcp:dataplex:GlossaryIamPolicy
    properties:
      project: ${glossaryTestId.project}
      location: ${glossaryTestId.location}
      glossaryId: ${glossaryTestId.glossaryId}
      policyData: ${admin.policyData}
variables:
  admin:
    fn::invoke:
      function: gcp:organizations:getIAMPolicy
      arguments:
        bindings:
          - role: roles/viewer
            members:
              - user:jane@example.com

The policyData property accepts output from getIAMPolicy, which defines bindings as role-to-members mappings. This resource is fully authoritative: it replaces all existing IAM bindings on the glossary. Use this when you need complete control over who can access the glossary.

Beyond these examples

These snippets focus on specific IAM management approaches: single-member grants, role-level member lists, and complete policy replacement. They’re intentionally minimal rather than full access control configurations.

The examples reference pre-existing infrastructure such as Dataplex glossaries (glossaryId) and GCP projects and locations. They focus on granting permissions rather than provisioning the glossaries themselves.

To keep things focused, common IAM patterns are omitted, including:

Conditional IAM bindings (condition property)
Custom role definitions
Service account creation
Glossary resource provisioning

These omissions are intentional: the goal is to illustrate how each IAM resource type is wired, not provide drop-in access control modules. See the Dataplex Glossary IAM Member resource reference for all available configuration options.

Let's manage GCP Dataplex Glossary IAM Access

Get started with Pulumi Cloud, then follow our quick setup guide to deploy this infrastructure.

Try Pulumi Cloud for FREE

Frequently Asked Questions

Resource Selection & Conflicts

Which IAM resource should I use to manage Dataplex Glossary permissions?

You have three options:

gcp.dataplex.GlossaryIamPolicy - Authoritative. Sets the entire IAM policy and replaces any existing policy.
gcp.dataplex.GlossaryIamBinding - Authoritative for a specific role. Grants a role to a list of members while preserving other roles.
gcp.dataplex.GlossaryIamMember - Non-authoritative. Adds a single member to a role while preserving other members.

Can I use GlossaryIamPolicy with GlossaryIamBinding or GlossaryIamMember?

No, gcp.dataplex.GlossaryIamPolicy cannot be used together with gcp.dataplex.GlossaryIamBinding or gcp.dataplex.GlossaryIamMember because they will conflict over the policy configuration.

Can I use GlossaryIamBinding and GlossaryIamMember together?

Yes, but only if they don’t grant privileges to the same role. Using both resources for the same role will cause conflicts.

Configuration & Identity Formats

What member identity formats are supported?

The member property supports multiple formats:

allUsers - Anyone on the internet
allAuthenticatedUsers - Anyone with a Google account
user:{emailid} - Specific Google account (e.g., user:alice@gmail.com)
serviceAccount:{emailid} - Service account (e.g., serviceAccount:my-app@appspot.gserviceaccount.com)
group:{emailid} - Google group (e.g., group:admins@example.com)
domain:{domain} - G Suite domain (e.g., domain:example.com)
projectOwner:projectid, projectEditor:projectid, projectViewer:projectid - Project-level roles
principal://... - Federated identities (workload/workforce identity pools)

How do I specify a custom IAM role?

Custom roles must use the format [projects|organizations]/{parent-name}/roles/{role-name}. For example, projects/my-project/roles/my-custom-role or organizations/my-org/roles/my-custom-role.

What properties are immutable after creation?

All core properties are immutable: glossaryId, location, project, member, role, and condition. You cannot modify these after the resource is created.

Import & Advanced Usage

How do I import an existing IAM member binding?

Use space-delimited identifiers with the resource path, role, and member identity:

pulumi import gcp:dataplex/glossaryIamMember:GlossaryIamMember editor "projects/{{project}}/locations/{{location}}/glossaries/{{glossary_id}} roles/viewer user:jane@example.com"

Using a different cloud?

Explore security guides for other cloud providers:

AWS Guides Azure Guides