The gcp:endpoints/serviceIamBinding:ServiceIamBinding resource, part of the Pulumi GCP provider, grants a specific IAM role to a list of members for a Cloud Endpoints service, replacing any existing members for that role. This guide focuses on two capabilities: binding multiple members to a single role and adding individual members non-authoritatively.
IAM bindings reference existing Cloud Endpoints services and assume identities already exist in your GCP organization. The examples are intentionally small. Combine them with your own service definitions and identity management.
Grant a role to multiple members at once
Teams managing Cloud Endpoints services often need to grant the same role to multiple users or service accounts simultaneously, such as giving viewer access to a development team.
import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const binding = new gcp.endpoints.ServiceIamBinding("binding", {
serviceName: endpointsService.serviceName,
role: "roles/viewer",
members: ["user:jane@example.com"],
});
import pulumi
import pulumi_gcp as gcp
binding = gcp.endpoints.ServiceIamBinding("binding",
service_name=endpoints_service["serviceName"],
role="roles/viewer",
members=["user:jane@example.com"])
package main
import (
"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/endpoints"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := endpoints.NewServiceIamBinding(ctx, "binding", &endpoints.ServiceIamBindingArgs{
ServiceName: pulumi.Any(endpointsService.ServiceName),
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.Endpoints.ServiceIamBinding("binding", new()
{
ServiceName = endpointsService.ServiceName,
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.endpoints.ServiceIamBinding;
import com.pulumi.gcp.endpoints.ServiceIamBindingArgs;
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 ServiceIamBinding("binding", ServiceIamBindingArgs.builder()
.serviceName(endpointsService.serviceName())
.role("roles/viewer")
.members("user:jane@example.com")
.build());
}
}
resources:
binding:
type: gcp:endpoints:ServiceIamBinding
properties:
serviceName: ${endpointsService.serviceName}
role: roles/viewer
members:
- user:jane@example.com
The ServiceIamBinding resource is authoritative for the specified role: it replaces all existing members for that role with the list you provide. The members array accepts various identity formats including user emails, service accounts, groups, and special identifiers like allUsers. The serviceName property references your Cloud Endpoints service, and role specifies which permission set to grant.
Add individual members to a role incrementally
When access needs to be granted one person at a time, or when multiple teams manage different members for the same role, non-authoritative member grants prevent conflicts.
import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const member = new gcp.endpoints.ServiceIamMember("member", {
serviceName: endpointsService.serviceName,
role: "roles/viewer",
member: "user:jane@example.com",
});
import pulumi
import pulumi_gcp as gcp
member = gcp.endpoints.ServiceIamMember("member",
service_name=endpoints_service["serviceName"],
role="roles/viewer",
member="user:jane@example.com")
package main
import (
"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/endpoints"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := endpoints.NewServiceIamMember(ctx, "member", &endpoints.ServiceIamMemberArgs{
ServiceName: pulumi.Any(endpointsService.ServiceName),
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.Endpoints.ServiceIamMember("member", new()
{
ServiceName = endpointsService.ServiceName,
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.endpoints.ServiceIamMember;
import com.pulumi.gcp.endpoints.ServiceIamMemberArgs;
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 ServiceIamMember("member", ServiceIamMemberArgs.builder()
.serviceName(endpointsService.serviceName())
.role("roles/viewer")
.member("user:jane@example.com")
.build());
}
}
resources:
member:
type: gcp:endpoints:ServiceIamMember
properties:
serviceName: ${endpointsService.serviceName}
role: roles/viewer
member: user:jane@example.com
The ServiceIamMember resource is non-authoritative: it adds a single member to a role without affecting other members. This allows multiple Pulumi stacks or teams to manage different members for the same role independently. Use member (singular) instead of members (plural) to specify one identity at a time.
Beyond these examples
These snippets focus on specific IAM binding features: role-based access control and binding vs member grant patterns. They’re intentionally minimal rather than full access control configurations.
The examples reference pre-existing infrastructure such as Cloud Endpoints services. They focus on configuring IAM grants rather than provisioning services or identities.
To keep things focused, common IAM patterns are omitted, including:
- Conditional IAM bindings (condition property)
- Full policy replacement (ServiceIamPolicy resource)
- Custom role definitions
- Service account creation and management
These omissions are intentional: the goal is to illustrate how each IAM grant pattern is wired, not provide drop-in access control modules. See the Cloud Endpoints ServiceIamBinding resource reference for all available configuration options.
Let's manage GCP Endpoints Service IAM Permissions
Get started with Pulumi Cloud, then follow our quick setup guide to deploy this infrastructure.
Try Pulumi Cloud for FREEFrequently Asked Questions
Resource Conflicts & Compatibility
gcp.endpoints.ServiceIamPolicy cannot be used with gcp.endpoints.ServiceIamBinding or gcp.endpoints.ServiceIamMember because they will conflict over policy control.Resource Selection & Use Cases
Choose based on your needs:
- ServiceIamPolicy: Authoritative control of the entire IAM policy (replaces any existing policy)
- ServiceIamBinding: Authoritative control of a specific role (preserves other roles)
- ServiceIamMember: Non-authoritative, adds a single member to a role (preserves other members)
Configuration & Formats
allUsers, allAuthenticatedUsers, user:{emailid}, serviceAccount:{emailid}, group:{emailid}, domain:{domain}, projectOwner:projectid, projectEditor:projectid, projectViewer:projectid, or federated identities like principal://iam.googleapis.com/....[projects|organizations]/{parent-name}/roles/{role-name}. For example, projects/my-project/roles/my-custom-role.Immutability & Updates
role, serviceName, and condition properties are immutable and cannot be changed after creation.etag is a computed output property representing the IAM policy’s version, used for concurrency control.