Manage GCP BigQuery Analytics Hub Listing IAM Policies

The gcp:bigqueryanalyticshub/listingIamPolicy:ListingIamPolicy resource, part of the Pulumi GCP provider, controls IAM permissions for BigQuery Analytics Hub listings, determining who can view or subscribe to shared datasets. This guide focuses on three approaches: authoritative policy replacement, role-level member binding, and incremental member addition.

These resources reference existing Analytics Hub listings and require project, location, dataExchangeId, and listingId identifiers. The examples are intentionally small. Combine them with your own listing infrastructure and organizational IAM policies.

Replace the entire IAM policy for a listing

When you need complete control over listing access, you can set the entire IAM policy at once, replacing any existing permissions.

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.bigqueryanalyticshub.ListingIamPolicy("policy", {
    project: listing.project,
    location: listing.location,
    dataExchangeId: listing.dataExchangeId,
    listingId: listing.listingId,
    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.bigqueryanalyticshub.ListingIamPolicy("policy",
    project=listing["project"],
    location=listing["location"],
    data_exchange_id=listing["dataExchangeId"],
    listing_id=listing["listingId"],
    policy_data=admin.policy_data)

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/bigqueryanalyticshub"
	"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 = bigqueryanalyticshub.NewListingIamPolicy(ctx, "policy", &bigqueryanalyticshub.ListingIamPolicyArgs{
			Project:        pulumi.Any(listing.Project),
			Location:       pulumi.Any(listing.Location),
			DataExchangeId: pulumi.Any(listing.DataExchangeId),
			ListingId:      pulumi.Any(listing.ListingId),
			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.BigQueryAnalyticsHub.ListingIamPolicy("policy", new()
    {
        Project = listing.Project,
        Location = listing.Location,
        DataExchangeId = listing.DataExchangeId,
        ListingId = listing.ListingId,
        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.bigqueryanalyticshub.ListingIamPolicy;
import com.pulumi.gcp.bigqueryanalyticshub.ListingIamPolicyArgs;
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 ListingIamPolicy("policy", ListingIamPolicyArgs.builder()
            .project(listing.project())
            .location(listing.location())
            .dataExchangeId(listing.dataExchangeId())
            .listingId(listing.listingId())
            .policyData(admin.policyData())
            .build());

    }
}

resources:
  policy:
    type: gcp:bigqueryanalyticshub:ListingIamPolicy
    properties:
      project: ${listing.project}
      location: ${listing.location}
      dataExchangeId: ${listing.dataExchangeId}
      listingId: ${listing.listingId}
      policyData: ${admin.policyData}
variables:
  admin:
    fn::invoke:
      function: gcp:organizations:getIAMPolicy
      arguments:
        bindings:
          - role: roles/viewer
            members:
              - user:jane@example.com

The ListingIamPolicy resource is authoritative: it replaces the entire IAM policy with the policyData you provide. The getIAMPolicy data source constructs the policy structure with bindings that map roles to members. This approach gives you full control but requires managing all permissions in one place. The resource cannot be used alongside ListingIamBinding or ListingIamMember, as they would conflict over policy ownership.

Grant a role to multiple members at once

When multiple users or service accounts need the same access level, you can bind them all to a single role without affecting other role assignments.

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

const binding = new gcp.bigqueryanalyticshub.ListingIamBinding("binding", {
    project: listing.project,
    location: listing.location,
    dataExchangeId: listing.dataExchangeId,
    listingId: listing.listingId,
    role: "roles/viewer",
    members: ["user:jane@example.com"],
});

import pulumi
import pulumi_gcp as gcp

binding = gcp.bigqueryanalyticshub.ListingIamBinding("binding",
    project=listing["project"],
    location=listing["location"],
    data_exchange_id=listing["dataExchangeId"],
    listing_id=listing["listingId"],
    role="roles/viewer",
    members=["user:jane@example.com"])

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := bigqueryanalyticshub.NewListingIamBinding(ctx, "binding", &bigqueryanalyticshub.ListingIamBindingArgs{
			Project:        pulumi.Any(listing.Project),
			Location:       pulumi.Any(listing.Location),
			DataExchangeId: pulumi.Any(listing.DataExchangeId),
			ListingId:      pulumi.Any(listing.ListingId),
			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.BigQueryAnalyticsHub.ListingIamBinding("binding", new()
    {
        Project = listing.Project,
        Location = listing.Location,
        DataExchangeId = listing.DataExchangeId,
        ListingId = listing.ListingId,
        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.bigqueryanalyticshub.ListingIamBinding;
import com.pulumi.gcp.bigqueryanalyticshub.ListingIamBindingArgs;
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 ListingIamBinding("binding", ListingIamBindingArgs.builder()
            .project(listing.project())
            .location(listing.location())
            .dataExchangeId(listing.dataExchangeId())
            .listingId(listing.listingId())
            .role("roles/viewer")
            .members("user:jane@example.com")
            .build());

    }
}

resources:
  binding:
    type: gcp:bigqueryanalyticshub:ListingIamBinding
    properties:
      project: ${listing.project}
      location: ${listing.location}
      dataExchangeId: ${listing.dataExchangeId}
      listingId: ${listing.listingId}
      role: roles/viewer
      members:
        - user:jane@example.com

The ListingIamBinding resource is authoritative for a specific role: it sets the complete member list for that role while preserving other roles in the policy. The members property accepts an array of identity strings (users, service accounts, groups). You can use multiple ListingIamBinding resources for different roles, or combine them with ListingIamMember resources as long as they don’t target the same role.

Add a single member to a role incrementally

When you need to grant access to one identity without disturbing existing permissions, you can add individual members to roles.

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

const member = new gcp.bigqueryanalyticshub.ListingIamMember("member", {
    project: listing.project,
    location: listing.location,
    dataExchangeId: listing.dataExchangeId,
    listingId: listing.listingId,
    role: "roles/viewer",
    member: "user:jane@example.com",
});

import pulumi
import pulumi_gcp as gcp

member = gcp.bigqueryanalyticshub.ListingIamMember("member",
    project=listing["project"],
    location=listing["location"],
    data_exchange_id=listing["dataExchangeId"],
    listing_id=listing["listingId"],
    role="roles/viewer",
    member="user:jane@example.com")

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := bigqueryanalyticshub.NewListingIamMember(ctx, "member", &bigqueryanalyticshub.ListingIamMemberArgs{
			Project:        pulumi.Any(listing.Project),
			Location:       pulumi.Any(listing.Location),
			DataExchangeId: pulumi.Any(listing.DataExchangeId),
			ListingId:      pulumi.Any(listing.ListingId),
			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.BigQueryAnalyticsHub.ListingIamMember("member", new()
    {
        Project = listing.Project,
        Location = listing.Location,
        DataExchangeId = listing.DataExchangeId,
        ListingId = listing.ListingId,
        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.bigqueryanalyticshub.ListingIamMember;
import com.pulumi.gcp.bigqueryanalyticshub.ListingIamMemberArgs;
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 ListingIamMember("member", ListingIamMemberArgs.builder()
            .project(listing.project())
            .location(listing.location())
            .dataExchangeId(listing.dataExchangeId())
            .listingId(listing.listingId())
            .role("roles/viewer")
            .member("user:jane@example.com")
            .build());

    }
}

resources:
  member:
    type: gcp:bigqueryanalyticshub:ListingIamMember
    properties:
      project: ${listing.project}
      location: ${listing.location}
      dataExchangeId: ${listing.dataExchangeId}
      listingId: ${listing.listingId}
      role: roles/viewer
      member: user:jane@example.com

The ListingIamMember resource is non-authoritative: it adds one member to a role without affecting other members already assigned to that role. The member property takes a single identity string. This approach works well when different teams or systems manage access for different users, as each resource operates independently. You can combine multiple ListingIamMember resources freely, and mix them with ListingIamBinding resources for different roles.

Beyond these examples

These snippets focus on specific IAM management approaches: authoritative policy replacement, role-level member binding, and incremental member addition. They’re intentionally minimal rather than complete access control solutions.

The examples reference pre-existing infrastructure such as BigQuery Analytics Hub listings (dataExchangeId and listingId) and GCP projects with appropriate locations. They focus on configuring IAM permissions rather than provisioning the listings themselves.

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

Conditional IAM bindings (condition blocks)
Custom role definitions
Policy conflict resolution strategies
Audit logging configuration

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 ListingIamPolicy resource reference for all available configuration options.

Let's manage GCP BigQuery Analytics Hub Listing IAM Policies

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

Can I use ListingIamPolicy with ListingIamBinding or ListingIamMember?

No, ListingIamPolicy cannot be used with ListingIamBinding or ListingIamMember because they will conflict over policy state. Additionally, ListingIamBinding and ListingIamMember can only be used together if they don’t manage the same role.

Which IAM resource should I use for managing listing permissions?

Choose based on your needs: ListingIamPolicy sets the entire policy authoritatively (replaces existing), ListingIamBinding manages all members for a specific role authoritatively, or ListingIamMember adds individual members non-authoritatively (preserves other members).

Configuration & Setup

How do I generate the policyData for ListingIamPolicy?

Use the gcp.organizations.getIAMPolicy data source with your desired bindings, then pass its policyData output to the ListingIamPolicy resource’s policyData property.

What properties can't I change after creating the resource?

The dataExchangeId, listingId, location, and project properties are all immutable. Only policyData can be updated after creation.

Import & Migration

What identifier formats are supported when importing?

Four formats are supported: projects/{{project}}/locations/{{location}}/dataExchanges/{{data_exchange_id}}/listings/{{listing_id}}, {{project}}/{{location}}/{{data_exchange_id}}/{{listing_id}}, {{location}}/{{data_exchange_id}}/{{listing_id}}, or just {{listing_id}}. Missing values are taken from the provider configuration.

Using a different cloud?

Explore security guides for other cloud providers:

AWS Guides Azure Guides