Manage GCP Backend Bucket IAM Bindings

The gcp:compute/backendBucketIamBinding:BackendBucketIamBinding resource, part of the Pulumi GCP provider, manages IAM role bindings for backend buckets. This resource is authoritative for a given role, meaning it controls the complete list of members who have that role. This guide focuses on two capabilities: authoritative role bindings for multiple members and non-authoritative member grants.

IAM bindings reference existing backend buckets and require a configured GCP project. The examples are intentionally small. Combine them with your own backend bucket infrastructure and identity management.

Grant a role to multiple members

Teams managing backend bucket access typically need to grant the same role to multiple users or service accounts at once.

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

const binding = new gcp.compute.BackendBucketIamBinding("binding", {
    project: imageBackend.project,
    name: imageBackend.name,
    role: "roles/viewer",
    members: ["user:jane@example.com"],
});

import pulumi
import pulumi_gcp as gcp

binding = gcp.compute.BackendBucketIamBinding("binding",
    project=image_backend["project"],
    name=image_backend["name"],
    role="roles/viewer",
    members=["user:jane@example.com"])

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.NewBackendBucketIamBinding(ctx, "binding", &compute.BackendBucketIamBindingArgs{
			Project: pulumi.Any(imageBackend.Project),
			Name:    pulumi.Any(imageBackend.Name),
			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.Compute.BackendBucketIamBinding("binding", new()
    {
        Project = imageBackend.Project,
        Name = imageBackend.Name,
        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.compute.BackendBucketIamBinding;
import com.pulumi.gcp.compute.BackendBucketIamBindingArgs;
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 BackendBucketIamBinding("binding", BackendBucketIamBindingArgs.builder()
            .project(imageBackend.project())
            .name(imageBackend.name())
            .role("roles/viewer")
            .members("user:jane@example.com")
            .build());

    }
}

resources:
  binding:
    type: gcp:compute:BackendBucketIamBinding
    properties:
      project: ${imageBackend.project}
      name: ${imageBackend.name}
      role: roles/viewer
      members:
        - user:jane@example.com

The role property specifies which permission set to grant (e.g., “roles/viewer”). The members array lists all identities that receive this role. This binding is authoritative for the specified role, replacing any existing member list for that role on the backend bucket.

Add a single member to a role

When onboarding individual users or granting access to specific service accounts, non-authoritative member grants preserve existing assignments.

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

const member = new gcp.compute.BackendBucketIamMember("member", {
    project: imageBackend.project,
    name: imageBackend.name,
    role: "roles/viewer",
    member: "user:jane@example.com",
});

import pulumi
import pulumi_gcp as gcp

member = gcp.compute.BackendBucketIamMember("member",
    project=image_backend["project"],
    name=image_backend["name"],
    role="roles/viewer",
    member="user:jane@example.com")

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.NewBackendBucketIamMember(ctx, "member", &compute.BackendBucketIamMemberArgs{
			Project: pulumi.Any(imageBackend.Project),
			Name:    pulumi.Any(imageBackend.Name),
			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.Compute.BackendBucketIamMember("member", new()
    {
        Project = imageBackend.Project,
        Name = imageBackend.Name,
        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.compute.BackendBucketIamMember;
import com.pulumi.gcp.compute.BackendBucketIamMemberArgs;
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 BackendBucketIamMember("member", BackendBucketIamMemberArgs.builder()
            .project(imageBackend.project())
            .name(imageBackend.name())
            .role("roles/viewer")
            .member("user:jane@example.com")
            .build());

    }
}

resources:
  member:
    type: gcp:compute:BackendBucketIamMember
    properties:
      project: ${imageBackend.project}
      name: ${imageBackend.name}
      role: roles/viewer
      member: user:jane@example.com

The BackendBucketIamMember resource adds a single identity to a role without affecting other members. Unlike BackendBucketIamBinding, this is non-authoritative: it adds the member to the role rather than replacing the entire member list. Use member (singular) instead of members (array) to specify the identity.

Beyond these examples

These snippets focus on specific IAM binding features: role-based access control and authoritative vs non-authoritative grants. They’re intentionally minimal rather than full access management solutions.

The examples reference pre-existing infrastructure such as backend buckets (referenced by name) and GCP projects. They focus on configuring IAM bindings rather than provisioning the underlying resources.

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

Conditional IAM bindings (condition property)
Policy-level management (BackendBucketIamPolicy)
Custom role definitions
Federated identity configuration

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

Let's manage GCP Backend Bucket IAM Bindings

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 for Backend Bucket permissions?

Choose based on your management approach:

BackendBucketIamPolicy - Authoritative, replaces the entire IAM policy
BackendBucketIamBinding - Authoritative for a specific role, preserves other roles
BackendBucketIamMember - Non-authoritative, adds individual members while preserving others

Can I use BackendBucketIamPolicy with BackendBucketIamBinding or BackendBucketIamMember?

No, BackendBucketIamPolicy cannot be used with BackendBucketIamBinding or BackendBucketIamMember as they will conflict over policy control. Choose one approach: use Policy alone (authoritative) or use Binding/Member (granular).

Can I use BackendBucketIamBinding and BackendBucketIamMember together?

Yes, but only if they manage different roles. Each role must be managed by either Binding or Member, not both, to avoid conflicts.

Configuration & Constraints

What properties are immutable after creation?

The role, name, project, and condition properties cannot be changed after creation. You must recreate the resource to modify these values.

How do I specify custom IAM roles?

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.

Is this resource production-ready?

This resource is in beta and requires the terraform-provider-google-beta provider. Review beta resource considerations before using in production.

Member Identity Formats

What member identity formats are supported?

The members property supports multiple identity formats:

Public access: allUsers, allAuthenticatedUsers
Individual accounts: user:{email}, serviceAccount:{email}
Groups and domains: group:{email}, domain:{domain}
Project roles: projectOwner:{projectid}, projectEditor:{projectid}, projectViewer:{projectid}
Federated identities: principal://iam.googleapis.com/... (see Principal identifiers documentation)

Using a different cloud?

Explore security guides for other cloud providers:

AWS Guides Azure Guides