Manage GCP Region Backend Service IAM Permissions

The gcp:compute/regionBackendServiceIamMember:RegionBackendServiceIamMember resource, part of the Pulumi GCP provider, manages IAM permissions for regional backend services by granting roles to identities. This guide focuses on three capabilities: single-member role grants, time-limited access with IAM Conditions, and multi-member bindings and full policy replacement.

IAM resources reference existing RegionBackendService resources and require valid Google Cloud identities. The examples are intentionally small. Combine them with your own backend services and identity management.

Grant a role to a single member

Most IAM configurations start by granting a specific role to one identity without affecting other members who already have the same role.

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

const member = new gcp.compute.RegionBackendServiceIamMember("member", {
    project: _default.project,
    region: _default.region,
    name: _default.name,
    role: "roles/compute.admin",
    member: "user:jane@example.com",
});

import pulumi
import pulumi_gcp as gcp

member = gcp.compute.RegionBackendServiceIamMember("member",
    project=default["project"],
    region=default["region"],
    name=default["name"],
    role="roles/compute.admin",
    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.NewRegionBackendServiceIamMember(ctx, "member", &compute.RegionBackendServiceIamMemberArgs{
			Project: pulumi.Any(_default.Project),
			Region:  pulumi.Any(_default.Region),
			Name:    pulumi.Any(_default.Name),
			Role:    pulumi.String("roles/compute.admin"),
			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.RegionBackendServiceIamMember("member", new()
    {
        Project = @default.Project,
        Region = @default.Region,
        Name = @default.Name,
        Role = "roles/compute.admin",
        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.RegionBackendServiceIamMember;
import com.pulumi.gcp.compute.RegionBackendServiceIamMemberArgs;
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 RegionBackendServiceIamMember("member", RegionBackendServiceIamMemberArgs.builder()
            .project(default_.project())
            .region(default_.region())
            .name(default_.name())
            .role("roles/compute.admin")
            .member("user:jane@example.com")
            .build());

    }
}

resources:
  member:
    type: gcp:compute:RegionBackendServiceIamMember
    properties:
      project: ${default.project}
      region: ${default.region}
      name: ${default.name}
      role: roles/compute.admin
      member: user:jane@example.com

The member property specifies the identity receiving access, using formats like “user:email@example.com” or “serviceAccount:name@project.iam.gserviceaccount.com”. The role property defines the permission level. This non-authoritative resource preserves other members with the same role.

Grant time-limited access with IAM Conditions

Teams often need temporary access that expires automatically, such as contractor access or time-boxed incident response permissions.

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

const member = new gcp.compute.RegionBackendServiceIamMember("member", {
    project: _default.project,
    region: _default.region,
    name: _default.name,
    role: "roles/compute.admin",
    member: "user:jane@example.com",
    condition: {
        title: "expires_after_2019_12_31",
        description: "Expiring at midnight of 2019-12-31",
        expression: "request.time < timestamp(\"2020-01-01T00:00:00Z\")",
    },
});

import pulumi
import pulumi_gcp as gcp

member = gcp.compute.RegionBackendServiceIamMember("member",
    project=default["project"],
    region=default["region"],
    name=default["name"],
    role="roles/compute.admin",
    member="user:jane@example.com",
    condition={
        "title": "expires_after_2019_12_31",
        "description": "Expiring at midnight of 2019-12-31",
        "expression": "request.time < timestamp(\"2020-01-01T00:00:00Z\")",
    })

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.NewRegionBackendServiceIamMember(ctx, "member", &compute.RegionBackendServiceIamMemberArgs{
			Project: pulumi.Any(_default.Project),
			Region:  pulumi.Any(_default.Region),
			Name:    pulumi.Any(_default.Name),
			Role:    pulumi.String("roles/compute.admin"),
			Member:  pulumi.String("user:jane@example.com"),
			Condition: &compute.RegionBackendServiceIamMemberConditionArgs{
				Title:       pulumi.String("expires_after_2019_12_31"),
				Description: pulumi.String("Expiring at midnight of 2019-12-31"),
				Expression:  pulumi.String("request.time < timestamp(\"2020-01-01T00:00:00Z\")"),
			},
		})
		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.RegionBackendServiceIamMember("member", new()
    {
        Project = @default.Project,
        Region = @default.Region,
        Name = @default.Name,
        Role = "roles/compute.admin",
        Member = "user:jane@example.com",
        Condition = new Gcp.Compute.Inputs.RegionBackendServiceIamMemberConditionArgs
        {
            Title = "expires_after_2019_12_31",
            Description = "Expiring at midnight of 2019-12-31",
            Expression = "request.time < timestamp(\"2020-01-01T00:00:00Z\")",
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.compute.RegionBackendServiceIamMember;
import com.pulumi.gcp.compute.RegionBackendServiceIamMemberArgs;
import com.pulumi.gcp.compute.inputs.RegionBackendServiceIamMemberConditionArgs;
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 RegionBackendServiceIamMember("member", RegionBackendServiceIamMemberArgs.builder()
            .project(default_.project())
            .region(default_.region())
            .name(default_.name())
            .role("roles/compute.admin")
            .member("user:jane@example.com")
            .condition(RegionBackendServiceIamMemberConditionArgs.builder()
                .title("expires_after_2019_12_31")
                .description("Expiring at midnight of 2019-12-31")
                .expression("request.time < timestamp(\"2020-01-01T00:00:00Z\")")
                .build())
            .build());

    }
}

resources:
  member:
    type: gcp:compute:RegionBackendServiceIamMember
    properties:
      project: ${default.project}
      region: ${default.region}
      name: ${default.name}
      role: roles/compute.admin
      member: user:jane@example.com
      condition:
        title: expires_after_2019_12_31
        description: Expiring at midnight of 2019-12-31
        expression: request.time < timestamp("2020-01-01T00:00:00Z")

The condition block adds time-based constraints to the role grant. The expression property uses CEL (Common Expression Language) to define when access is valid. Here, access expires at midnight on 2019-12-31. The title and description help identify the condition’s purpose in audit logs.

Grant a role to multiple members at once

When multiple identities need the same role, a binding resource manages them as a group, replacing any members not listed.

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

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

import pulumi
import pulumi_gcp as gcp

binding = gcp.compute.RegionBackendServiceIamBinding("binding",
    project=default["project"],
    region=default["region"],
    name=default["name"],
    role="roles/compute.admin",
    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.NewRegionBackendServiceIamBinding(ctx, "binding", &compute.RegionBackendServiceIamBindingArgs{
			Project: pulumi.Any(_default.Project),
			Region:  pulumi.Any(_default.Region),
			Name:    pulumi.Any(_default.Name),
			Role:    pulumi.String("roles/compute.admin"),
			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.RegionBackendServiceIamBinding("binding", new()
    {
        Project = @default.Project,
        Region = @default.Region,
        Name = @default.Name,
        Role = "roles/compute.admin",
        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.RegionBackendServiceIamBinding;
import com.pulumi.gcp.compute.RegionBackendServiceIamBindingArgs;
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 RegionBackendServiceIamBinding("binding", RegionBackendServiceIamBindingArgs.builder()
            .project(default_.project())
            .region(default_.region())
            .name(default_.name())
            .role("roles/compute.admin")
            .members("user:jane@example.com")
            .build());

    }
}

resources:
  binding:
    type: gcp:compute:RegionBackendServiceIamBinding
    properties:
      project: ${default.project}
      region: ${default.region}
      name: ${default.name}
      role: roles/compute.admin
      members:
        - user:jane@example.com

The members property lists all identities that should have the role. This binding is authoritative for the specified role: it replaces any existing members not in the list. Use RegionBackendServiceIamMember instead if you need to preserve other members.

Replace the entire IAM policy

Some deployments require complete control over all IAM bindings, replacing any existing policy with a new one.

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

const admin = gcp.organizations.getIAMPolicy({
    bindings: [{
        role: "roles/compute.admin",
        members: ["user:jane@example.com"],
    }],
});
const policy = new gcp.compute.RegionBackendServiceIamPolicy("policy", {
    project: _default.project,
    region: _default.region,
    name: _default.name,
    policyData: admin.then(admin => admin.policyData),
});

import pulumi
import pulumi_gcp as gcp

admin = gcp.organizations.get_iam_policy(bindings=[{
    "role": "roles/compute.admin",
    "members": ["user:jane@example.com"],
}])
policy = gcp.compute.RegionBackendServiceIamPolicy("policy",
    project=default["project"],
    region=default["region"],
    name=default["name"],
    policy_data=admin.policy_data)

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/compute"
	"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/compute.admin",
					Members: []string{
						"user:jane@example.com",
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		_, err = compute.NewRegionBackendServiceIamPolicy(ctx, "policy", &compute.RegionBackendServiceIamPolicyArgs{
			Project:    pulumi.Any(_default.Project),
			Region:     pulumi.Any(_default.Region),
			Name:       pulumi.Any(_default.Name),
			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/compute.admin",
                Members = new[]
                {
                    "user:jane@example.com",
                },
            },
        },
    });

    var policy = new Gcp.Compute.RegionBackendServiceIamPolicy("policy", new()
    {
        Project = @default.Project,
        Region = @default.Region,
        Name = @default.Name,
        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.compute.RegionBackendServiceIamPolicy;
import com.pulumi.gcp.compute.RegionBackendServiceIamPolicyArgs;
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/compute.admin")
                .members("user:jane@example.com")
                .build())
            .build());

        var policy = new RegionBackendServiceIamPolicy("policy", RegionBackendServiceIamPolicyArgs.builder()
            .project(default_.project())
            .region(default_.region())
            .name(default_.name())
            .policyData(admin.policyData())
            .build());

    }
}

resources:
  policy:
    type: gcp:compute:RegionBackendServiceIamPolicy
    properties:
      project: ${default.project}
      region: ${default.region}
      name: ${default.name}
      policyData: ${admin.policyData}
variables:
  admin:
    fn::invoke:
      function: gcp:organizations:getIAMPolicy
      arguments:
        bindings:
          - role: roles/compute.admin
            members:
              - user:jane@example.com

The policyData property accepts a complete IAM policy document from getIAMPolicy. This resource is authoritative for the entire policy: it replaces all existing bindings. It cannot be used alongside RegionBackendServiceIamBinding or RegionBackendServiceIamMember, as they would conflict over policy state.

Beyond these examples

These snippets focus on specific IAM management features: single-member and multi-member role grants, time-based access with IAM Conditions, and full policy replacement. They’re intentionally minimal rather than complete access control systems.

The examples reference pre-existing infrastructure such as RegionBackendService resources and Google Cloud identities (users, service accounts, groups). They focus on configuring IAM permissions rather than provisioning the backend services themselves.

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

Custom role definitions and formatting
Federated identity configuration
Policy conflict resolution between resource types
Audit logging for IAM changes

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

Let's manage GCP Region Backend Service IAM Permissions

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 managing backend service permissions?

You have three options:

RegionBackendServiceIamPolicy - Authoritative, replaces the entire IAM policy
RegionBackendServiceIamBinding - Authoritative for a specific role, manages all members for that role
RegionBackendServiceIamMember - Non-authoritative, adds individual members without affecting others

Can I use RegionBackendServiceIamPolicy with Binding or Member resources?

No, RegionBackendServiceIamPolicy cannot be used with RegionBackendServiceIamBinding or RegionBackendServiceIamMember because they will conflict over policy control. However, you can use RegionBackendServiceIamBinding and RegionBackendServiceIamMember together as long as they don’t grant the same role.

Identity & Role Configuration

What identity formats are supported for the member parameter?

The member parameter supports multiple formats:

allUsers or allAuthenticatedUsers for public/authenticated access
user:{email}, serviceAccount:{email}, group:{email} for specific identities
domain:{domain} for G Suite domains
projectOwner:{projectid}, projectEditor:{projectid}, projectViewer:{projectid} for project roles
Federated identities using principal identifiers (e.g., principal://iam.googleapis.com/...)

How do I specify custom IAM roles?

Custom roles must use the full 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.

Advanced Features & Limitations

How do I add time-based or conditional access using IAM Conditions?

Add a condition block with title, description, and expression fields. For example, to expire access at a specific time, use expression: "request.time < timestamp(\"2020-01-01T00:00:00Z\")".

What are the limitations of IAM Conditions for this resource?

IAM Conditions are supported but have known limitations. The condition property is immutable after creation, and you should review the GCP IAM Conditions documentation for specific constraints.

Is this resource production-ready?

This resource is in beta and requires the terraform-provider-google-beta provider. Review the provider documentation for details on using beta resources.

Using a different cloud?

Explore security guides for other cloud providers:

AWS Guides Azure Guides