The gcp:iap/tunnelIamBinding:TunnelIamBinding resource, part of the Pulumi GCP provider, manages IAM bindings for Identity-Aware Proxy tunnels, controlling which users and service accounts can access resources through IAP. This guide focuses on three capabilities: role-based bindings for multiple members, single-member grants, and time-based access with IAM Conditions.
IAM bindings reference an existing GCP project with IAP enabled and an IAP tunnel resource. The examples are intentionally small. Combine them with your own project configuration and access policies.
Grant a role to multiple members at once
Teams managing IAP tunnel access often need to grant the same role to multiple users or service accounts simultaneously, ensuring consistent permissions across a group.
import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const binding = new gcp.iap.TunnelIamBinding("binding", {
project: projectService.project,
role: "roles/iap.tunnelResourceAccessor",
members: ["user:jane@example.com"],
});
import pulumi
import pulumi_gcp as gcp
binding = gcp.iap.TunnelIamBinding("binding",
project=project_service["project"],
role="roles/iap.tunnelResourceAccessor",
members=["user:jane@example.com"])
package main
import (
"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/iap"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := iap.NewTunnelIamBinding(ctx, "binding", &iap.TunnelIamBindingArgs{
Project: pulumi.Any(projectService.Project),
Role: pulumi.String("roles/iap.tunnelResourceAccessor"),
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.Iap.TunnelIamBinding("binding", new()
{
Project = projectService.Project,
Role = "roles/iap.tunnelResourceAccessor",
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.iap.TunnelIamBinding;
import com.pulumi.gcp.iap.TunnelIamBindingArgs;
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 TunnelIamBinding("binding", TunnelIamBindingArgs.builder()
.project(projectService.project())
.role("roles/iap.tunnelResourceAccessor")
.members("user:jane@example.com")
.build());
}
}
resources:
binding:
type: gcp:iap:TunnelIamBinding
properties:
project: ${projectService.project}
role: roles/iap.tunnelResourceAccessor
members:
- user:jane@example.com
The TunnelIamBinding resource is authoritative for the specified role, meaning it replaces any existing members for that role. The members property accepts a list of identities (users, service accounts, groups, or special identifiers like allAuthenticatedUsers). The role property specifies which IAP permission to grant; roles/iap.tunnelResourceAccessor allows users to create IAP tunnels to resources.
Add a single member to an existing role
When onboarding individual users or service accounts, you often need to grant access without affecting other members who already have the role.
import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const member = new gcp.iap.TunnelIamMember("member", {
project: projectService.project,
role: "roles/iap.tunnelResourceAccessor",
member: "user:jane@example.com",
});
import pulumi
import pulumi_gcp as gcp
member = gcp.iap.TunnelIamMember("member",
project=project_service["project"],
role="roles/iap.tunnelResourceAccessor",
member="user:jane@example.com")
package main
import (
"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/iap"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := iap.NewTunnelIamMember(ctx, "member", &iap.TunnelIamMemberArgs{
Project: pulumi.Any(projectService.Project),
Role: pulumi.String("roles/iap.tunnelResourceAccessor"),
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.Iap.TunnelIamMember("member", new()
{
Project = projectService.Project,
Role = "roles/iap.tunnelResourceAccessor",
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.iap.TunnelIamMember;
import com.pulumi.gcp.iap.TunnelIamMemberArgs;
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 TunnelIamMember("member", TunnelIamMemberArgs.builder()
.project(projectService.project())
.role("roles/iap.tunnelResourceAccessor")
.member("user:jane@example.com")
.build());
}
}
resources:
member:
type: gcp:iap:TunnelIamMember
properties:
project: ${projectService.project}
role: roles/iap.tunnelResourceAccessor
member: user:jane@example.com
The TunnelIamMember resource is non-authoritative, meaning it adds one member to a role without removing existing members. This is useful when multiple teams manage access independently. The member property takes a single identity string, while the role property specifies the permission to grant.
Apply time-based access with IAM Conditions
Temporary access scenarios, such as contractor engagements or time-limited projects, require permissions that automatically expire without manual cleanup.
import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const binding = new gcp.iap.TunnelIamBinding("binding", {
project: projectService.project,
role: "roles/iap.tunnelResourceAccessor",
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.iap.TunnelIamBinding("binding",
project=project_service["project"],
role="roles/iap.tunnelResourceAccessor",
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/iap"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := iap.NewTunnelIamBinding(ctx, "binding", &iap.TunnelIamBindingArgs{
Project: pulumi.Any(projectService.Project),
Role: pulumi.String("roles/iap.tunnelResourceAccessor"),
Members: pulumi.StringArray{
pulumi.String("user:jane@example.com"),
},
Condition: &iap.TunnelIamBindingConditionArgs{
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.Iap.TunnelIamBinding("binding", new()
{
Project = projectService.Project,
Role = "roles/iap.tunnelResourceAccessor",
Members = new[]
{
"user:jane@example.com",
},
Condition = new Gcp.Iap.Inputs.TunnelIamBindingConditionArgs
{
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.iap.TunnelIamBinding;
import com.pulumi.gcp.iap.TunnelIamBindingArgs;
import com.pulumi.gcp.iap.inputs.TunnelIamBindingConditionArgs;
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 TunnelIamBinding("binding", TunnelIamBindingArgs.builder()
.project(projectService.project())
.role("roles/iap.tunnelResourceAccessor")
.members("user:jane@example.com")
.condition(TunnelIamBindingConditionArgs.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:iap:TunnelIamBinding
properties:
project: ${projectService.project}
role: roles/iap.tunnelResourceAccessor
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 add temporal or attribute-based constraints to bindings. The condition block requires a title for identification, an expression using Common Expression Language (CEL), and an optional description. The expression compares request.time against a timestamp to enforce expiration. Note that IAM Conditions have known limitations; review the GCP documentation if you encounter issues.
Beyond these examples
These snippets focus on specific IAM binding features: role-based bindings for multiple members, single-member grants, and time-based access with IAM Conditions. They’re intentionally minimal rather than full access control policies.
The examples reference pre-existing infrastructure such as a GCP project with IAP enabled and an IAP tunnel resource. They focus on configuring IAM bindings rather than provisioning the underlying IAP infrastructure.
To keep things focused, common IAM patterns are omitted, including:
- Full policy replacement (TunnelIamPolicy)
- Complex IAM Condition expressions (description, multiple conditions)
- Federated identity principals and workload identity
- Custom role definitions and organization-level roles
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 IAP TunnelIamBinding resource reference for all available configuration options.
Let's configure GCP IAP Tunnel 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.iap.TunnelIamPolicy cannot be used with gcp.iap.TunnelIamBinding or gcp.iap.TunnelIamMember as they will conflict over the policy. Choose one approach: use TunnelIamPolicy for full control, or use TunnelIamBinding/TunnelIamMember for granular management.gcp.iap.TunnelIamBinding can be used per role.IAM Configuration & Roles
TunnelIamPolicy is authoritative and replaces the entire IAM policy. TunnelIamBinding is authoritative for a specific role but preserves other roles. TunnelIamMember is non-authoritative and preserves other members for the role.[projects|organizations]/{parent-name}/roles/{role-name}. For example: projects/my-project/roles/customRole or organizations/my-org/roles/customRole.role, project, and condition properties are immutable and cannot be modified after the resource is created.Member Identities
allUsers, allAuthenticatedUsers, user:{email}, serviceAccount:{email}, group:{email}, domain:{domain}, projectOwner:{projectid}, projectEditor:{projectid}, projectViewer:{projectid}, and federated identities like principal://iam.googleapis.com/....Conditions & Advanced Features
condition property with title, description, and expression fields. For example: expression: "request.time < timestamp(\"2020-01-01T00:00:00Z\")" to expire access at a specific time.etag is a computed output representing the version of the IAM policy, useful for detecting concurrent modifications.