The gcp:compute/backendServiceIamBinding:BackendServiceIamBinding resource, part of the Pulumi GCP provider, manages IAM role bindings for Compute Engine backend services, controlling which identities can access or manage the service. This guide focuses on three capabilities: authoritative role binding with member lists, time-based conditional access, and non-authoritative member addition.
IAM bindings reference existing backend services and GCP projects. The examples are intentionally small. Combine them with your own backend service infrastructure and organizational access policies.
Grant a role to multiple members with BackendServiceIamBinding
Teams managing backend services often 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.BackendServiceIamBinding("binding", {
project: _default.project,
name: _default.name,
role: "roles/compute.admin",
members: ["user:jane@example.com"],
});
import pulumi
import pulumi_gcp as gcp
binding = gcp.compute.BackendServiceIamBinding("binding",
project=default["project"],
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.NewBackendServiceIamBinding(ctx, "binding", &compute.BackendServiceIamBindingArgs{
Project: pulumi.Any(_default.Project),
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.BackendServiceIamBinding("binding", new()
{
Project = @default.Project,
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.BackendServiceIamBinding;
import com.pulumi.gcp.compute.BackendServiceIamBindingArgs;
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 BackendServiceIamBinding("binding", BackendServiceIamBindingArgs.builder()
.project(default_.project())
.name(default_.name())
.role("roles/compute.admin")
.members("user:jane@example.com")
.build());
}
}
resources:
binding:
type: gcp:compute:BackendServiceIamBinding
properties:
project: ${default.project}
name: ${default.name}
role: roles/compute.admin
members:
- user:jane@example.com
The BackendServiceIamBinding resource authoritatively manages all members for a specific role. The members array lists all identities that receive the role; any members not in this list lose the role. The role property specifies which permission set to grant, and name identifies the backend service. Other roles on the same backend service remain unchanged.
Add time-based conditions to role bindings
Access grants sometimes need expiration dates for temporary contractors, audits, or time-limited projects.
import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const binding = new gcp.compute.BackendServiceIamBinding("binding", {
project: _default.project,
name: _default.name,
role: "roles/compute.admin",
members: ["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
binding = gcp.compute.BackendServiceIamBinding("binding",
project=default["project"],
name=default["name"],
role="roles/compute.admin",
members=["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.NewBackendServiceIamBinding(ctx, "binding", &compute.BackendServiceIamBindingArgs{
Project: pulumi.Any(_default.Project),
Name: pulumi.Any(_default.Name),
Role: pulumi.String("roles/compute.admin"),
Members: pulumi.StringArray{
pulumi.String("user:jane@example.com"),
},
Condition: &compute.BackendServiceIamBindingConditionArgs{
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 binding = new Gcp.Compute.BackendServiceIamBinding("binding", new()
{
Project = @default.Project,
Name = @default.Name,
Role = "roles/compute.admin",
Members = new[]
{
"user:jane@example.com",
},
Condition = new Gcp.Compute.Inputs.BackendServiceIamBindingConditionArgs
{
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.BackendServiceIamBinding;
import com.pulumi.gcp.compute.BackendServiceIamBindingArgs;
import com.pulumi.gcp.compute.inputs.BackendServiceIamBindingConditionArgs;
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 BackendServiceIamBinding("binding", BackendServiceIamBindingArgs.builder()
.project(default_.project())
.name(default_.name())
.role("roles/compute.admin")
.members("user:jane@example.com")
.condition(BackendServiceIamBindingConditionArgs.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:
binding:
type: gcp:compute:BackendServiceIamBinding
properties:
project: ${default.project}
name: ${default.name}
role: roles/compute.admin
members:
- 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")
IAM Conditions attach constraints to role bindings through the condition block. The expression property uses Common Expression Language (CEL) to define when access is valid; here, it checks that the request time is before midnight on January 1, 2020. The title and description properties document the condition’s purpose. Conditions have known limitations documented in the GCP IAM Conditions overview.
Add a single member to a role with BackendServiceIamMember
When you need to grant access to one additional user without affecting existing members, use BackendServiceIamMember for non-authoritative updates.
import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const member = new gcp.compute.BackendServiceIamMember("member", {
project: _default.project,
name: _default.name,
role: "roles/compute.admin",
member: "user:jane@example.com",
});
import pulumi
import pulumi_gcp as gcp
member = gcp.compute.BackendServiceIamMember("member",
project=default["project"],
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.NewBackendServiceIamMember(ctx, "member", &compute.BackendServiceIamMemberArgs{
Project: pulumi.Any(_default.Project),
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.BackendServiceIamMember("member", new()
{
Project = @default.Project,
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.BackendServiceIamMember;
import com.pulumi.gcp.compute.BackendServiceIamMemberArgs;
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 BackendServiceIamMember("member", BackendServiceIamMemberArgs.builder()
.project(default_.project())
.name(default_.name())
.role("roles/compute.admin")
.member("user:jane@example.com")
.build());
}
}
resources:
member:
type: gcp:compute:BackendServiceIamMember
properties:
project: ${default.project}
name: ${default.name}
role: roles/compute.admin
member: user:jane@example.com
The BackendServiceIamMember resource adds a single member to a role without managing the complete member list. The member property specifies one identity (user, service account, group, or domain). Unlike BackendServiceIamBinding, this resource preserves other members already assigned to the role. You can use multiple BackendServiceIamMember resources for the same role, or combine them with BackendServiceIamBinding resources for different roles.
Beyond these examples
These snippets focus on specific IAM binding features: role binding with member lists, conditional access with time constraints, and incremental member addition. They’re intentionally minimal rather than full access control policies.
The examples reference pre-existing infrastructure such as backend services and GCP projects. They focus on configuring access control rather than provisioning the backend services themselves.
To keep things focused, common IAM patterns are omitted, including:
- BackendServiceIamPolicy for full policy replacement
- Complex IAM Conditions (attribute-based, resource-based)
- Custom role definitions and formatting
- Federated identity and workload identity pool configuration
These omissions are intentional: the goal is to illustrate how each IAM binding feature is wired, not provide drop-in access control modules. See the BackendServiceIamBinding resource reference for all available configuration options.
Let's manage GCP Backend Service IAM Bindings
Get started with Pulumi Cloud, then follow our quick setup guide to deploy this infrastructure.
Try Pulumi Cloud for FREEFrequently Asked Questions
Resource Selection & Conflicts
You have three options:
gcp.compute.BackendServiceIamPolicy- Authoritative. Replaces the entire IAM policy.gcp.compute.BackendServiceIamBinding- Authoritative for a specific role. Preserves other roles.gcp.compute.BackendServiceIamMember- Non-authoritative. Adds individual members. Preserves other members for the role.
gcp.compute.BackendServiceIamPolicy cannot be used with gcp.compute.BackendServiceIamBinding or gcp.compute.BackendServiceIamMember because they will conflict over policy state.Configuration & Permissions
The members property accepts:
allUsersorallAuthenticatedUsers(special identifiers)user:{email},serviceAccount:{email},group:{email}(Google identities)domain:{domain}(G Suite domains)projectOwner:{projectid},projectEditor:{projectid},projectViewer:{projectid}(project roles)- Federated identities (e.g.,
principal://iam.googleapis.com/...)
[projects|organizations]/{parent-name}/roles/{role-name}. For example: projects/my-project/roles/customRole or organizations/my-org/roles/customRole.condition property with title, description, and expression fields. Example: expression: "request.time < timestamp(\"2020-01-01T00:00:00Z\")" expires access at midnight on 2020-01-01.role, name, project, and condition properties cannot be changed after creation. Modifying these requires recreating the resource.