Manage GCP BigQuery Connection IAM Policies

The gcp:bigquery/connectionIamPolicy:ConnectionIamPolicy resource, part of the Pulumi GCP provider, manages IAM permissions for BigQuery connections. This guide focuses on three approaches: authoritative policy replacement (ConnectionIamPolicy), role-level member management (ConnectionIamBinding), and individual member grants (ConnectionIamMember).

These three resources reference an existing BigQuery connection but differ in how they handle existing permissions. ConnectionIamPolicy replaces the entire policy, ConnectionIamBinding is authoritative for a single role, and ConnectionIamMember adds individual members non-authoritatively. The examples are intentionally small. Choose the resource that matches your permission management strategy.

Replace the entire IAM policy for a connection

When you need complete control over connection access, you can set the entire IAM policy at once.

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.bigquery.ConnectionIamPolicy("policy", {
    project: connection.project,
    location: connection.location,
    connectionId: connection.connectionId,
    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.bigquery.ConnectionIamPolicy("policy",
    project=connection["project"],
    location=connection["location"],
    connection_id=connection["connectionId"],
    policy_data=admin.policy_data)

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/bigquery"
	"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 = bigquery.NewConnectionIamPolicy(ctx, "policy", &bigquery.ConnectionIamPolicyArgs{
			Project:      pulumi.Any(connection.Project),
			Location:     pulumi.Any(connection.Location),
			ConnectionId: pulumi.Any(connection.ConnectionId),
			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.BigQuery.ConnectionIamPolicy("policy", new()
    {
        Project = connection.Project,
        Location = connection.Location,
        ConnectionId = connection.ConnectionId,
        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.bigquery.ConnectionIamPolicy;
import com.pulumi.gcp.bigquery.ConnectionIamPolicyArgs;
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 ConnectionIamPolicy("policy", ConnectionIamPolicyArgs.builder()
            .project(connection.project())
            .location(connection.location())
            .connectionId(connection.connectionId())
            .policyData(admin.policyData())
            .build());

    }
}

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

The ConnectionIamPolicy resource replaces any existing policy on the connection. The policyData property accepts output from the getIAMPolicy data source, which defines bindings (role-to-members mappings). This approach is authoritative: any permissions not in the policy are removed.

Grant a role to multiple members at once

Teams often grant the same role to several users without affecting other roles.

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

const binding = new gcp.bigquery.ConnectionIamBinding("binding", {
    project: connection.project,
    location: connection.location,
    connectionId: connection.connectionId,
    role: "roles/viewer",
    members: ["user:jane@example.com"],
});

import pulumi
import pulumi_gcp as gcp

binding = gcp.bigquery.ConnectionIamBinding("binding",
    project=connection["project"],
    location=connection["location"],
    connection_id=connection["connectionId"],
    role="roles/viewer",
    members=["user:jane@example.com"])

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := bigquery.NewConnectionIamBinding(ctx, "binding", &bigquery.ConnectionIamBindingArgs{
			Project:      pulumi.Any(connection.Project),
			Location:     pulumi.Any(connection.Location),
			ConnectionId: pulumi.Any(connection.ConnectionId),
			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.BigQuery.ConnectionIamBinding("binding", new()
    {
        Project = connection.Project,
        Location = connection.Location,
        ConnectionId = connection.ConnectionId,
        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.bigquery.ConnectionIamBinding;
import com.pulumi.gcp.bigquery.ConnectionIamBindingArgs;
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 ConnectionIamBinding("binding", ConnectionIamBindingArgs.builder()
            .project(connection.project())
            .location(connection.location())
            .connectionId(connection.connectionId())
            .role("roles/viewer")
            .members("user:jane@example.com")
            .build());

    }
}

resources:
  binding:
    type: gcp:bigquery:ConnectionIamBinding
    properties:
      project: ${connection.project}
      location: ${connection.location}
      connectionId: ${connection.connectionId}
      role: roles/viewer
      members:
        - user:jane@example.com

The ConnectionIamBinding resource is authoritative for a single role. The members array lists all users, groups, or service accounts that should have this role. Other roles on the connection remain unchanged, but this resource replaces all members for the specified role.

Add a single member to a role incrementally

To grant access to one user without disturbing existing permissions, add individual members.

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

const member = new gcp.bigquery.ConnectionIamMember("member", {
    project: connection.project,
    location: connection.location,
    connectionId: connection.connectionId,
    role: "roles/viewer",
    member: "user:jane@example.com",
});

import pulumi
import pulumi_gcp as gcp

member = gcp.bigquery.ConnectionIamMember("member",
    project=connection["project"],
    location=connection["location"],
    connection_id=connection["connectionId"],
    role="roles/viewer",
    member="user:jane@example.com")

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := bigquery.NewConnectionIamMember(ctx, "member", &bigquery.ConnectionIamMemberArgs{
			Project:      pulumi.Any(connection.Project),
			Location:     pulumi.Any(connection.Location),
			ConnectionId: pulumi.Any(connection.ConnectionId),
			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.BigQuery.ConnectionIamMember("member", new()
    {
        Project = connection.Project,
        Location = connection.Location,
        ConnectionId = connection.ConnectionId,
        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.bigquery.ConnectionIamMember;
import com.pulumi.gcp.bigquery.ConnectionIamMemberArgs;
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 ConnectionIamMember("member", ConnectionIamMemberArgs.builder()
            .project(connection.project())
            .location(connection.location())
            .connectionId(connection.connectionId())
            .role("roles/viewer")
            .member("user:jane@example.com")
            .build());

    }
}

resources:
  member:
    type: gcp:bigquery:ConnectionIamMember
    properties:
      project: ${connection.project}
      location: ${connection.location}
      connectionId: ${connection.connectionId}
      role: roles/viewer
      member: user:jane@example.com

The ConnectionIamMember resource is non-authoritative. It adds one member to a role without affecting other members already assigned to that role. Use this when you want to grant permissions incrementally without managing the full member list.

Beyond these examples

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

The examples reference pre-existing infrastructure such as a BigQuery connection (via connectionId) and a GCP project and location. They focus on IAM binding configuration rather than connection provisioning.

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

Conditional IAM bindings (condition property)
Custom IAM roles (examples use roles/viewer only)
Service account impersonation
IAM policy retrieval (data source usage)

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

Let's manage GCP BigQuery Connection 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

What's the difference between ConnectionIamPolicy, ConnectionIamBinding, and ConnectionIamMember?

ConnectionIamPolicy is authoritative and replaces the entire IAM policy. ConnectionIamBinding is authoritative for a specific role but preserves other roles. ConnectionIamMember is non-authoritative and adds a single member while preserving other members for that role.

Can I use ConnectionIamPolicy with ConnectionIamBinding or ConnectionIamMember?

No, ConnectionIamPolicy cannot be used with ConnectionIamBinding or ConnectionIamMember because they will conflict over policy management. Choose one approach: use ConnectionIamPolicy alone, or use ConnectionIamBinding and ConnectionIamMember together.

Can I use ConnectionIamBinding and ConnectionIamMember together?

Yes, but only if they manage different roles. Using both resources for the same role will cause conflicts.

Configuration & Location

Which location should I use for my BigQuery connection?

The connection must be in the same location as your data source, with exceptions: Cloud SQL us-central1 maps to BigQuery US, and europe-west1 maps to EU. Spanner connections use the same region. AWS supports aws-us-east-1, Azure supports azure-eastus2.

What happens if I don't specify a location or project?

Both location and project will be parsed from the parent resource identifier if not specified. If still unavailable, location comes from the provider configuration and project uses the provider project.

Import & Migration

How do I import an existing IAM policy for a BigQuery connection?

Use the resource identifier in one of these formats: projects/{{project}}/locations/{{location}}/connections/{{connection_id}}, {{project}}/{{location}}/{{connection_id}}, {{location}}/{{connection_id}}, or {{connection_id}}. For IAM member imports, add the role and member identity space-delimited (e.g., "projects/.../connections/my-conn roles/viewer user:jane@example.com").

Using a different cloud?

Explore security guides for other cloud providers:

AWS Guides Azure Guides