Manage GCP App Engine IAP Service Permissions

The gcp:iap/appEngineServiceIamMember:AppEngineServiceIamMember resource, part of the Pulumi GCP provider, grants IAM permissions to access IAP-protected App Engine services by adding individual members to roles without replacing existing permissions. This guide focuses on three capabilities: single-member IAM grants, time-limited access with IAM Conditions, and multi-member role bindings.

IAM resources for IAP come in three variants: AppEngineServiceIamPolicy (authoritative, replaces entire policy), AppEngineServiceIamBinding (authoritative for one role, replaces all members), and AppEngineServiceIamMember (non-authoritative, adds one member). All examples reference existing App Engine services and assume IAP is already enabled. The examples are intentionally small. Combine them with your own App Engine infrastructure and identity management.

Grant a single user access to an App Engine service

Most IAP configurations start by granting individual users access to specific services without affecting other members who already have permissions.

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

const member = new gcp.iap.AppEngineServiceIamMember("member", {
    project: version.project,
    appId: version.project,
    service: version.service,
    role: "roles/iap.httpsResourceAccessor",
    member: "user:jane@example.com",
});

import pulumi
import pulumi_gcp as gcp

member = gcp.iap.AppEngineServiceIamMember("member",
    project=version["project"],
    app_id=version["project"],
    service=version["service"],
    role="roles/iap.httpsResourceAccessor",
    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.NewAppEngineServiceIamMember(ctx, "member", &iap.AppEngineServiceIamMemberArgs{
			Project: pulumi.Any(version.Project),
			AppId:   pulumi.Any(version.Project),
			Service: pulumi.Any(version.Service),
			Role:    pulumi.String("roles/iap.httpsResourceAccessor"),
			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.AppEngineServiceIamMember("member", new()
    {
        Project = version.Project,
        AppId = version.Project,
        Service = version.Service,
        Role = "roles/iap.httpsResourceAccessor",
        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.AppEngineServiceIamMember;
import com.pulumi.gcp.iap.AppEngineServiceIamMemberArgs;
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 AppEngineServiceIamMember("member", AppEngineServiceIamMemberArgs.builder()
            .project(version.project())
            .appId(version.project())
            .service(version.service())
            .role("roles/iap.httpsResourceAccessor")
            .member("user:jane@example.com")
            .build());

    }
}

resources:
  member:
    type: gcp:iap:AppEngineServiceIamMember
    properties:
      project: ${version.project}
      appId: ${version.project}
      service: ${version.service}
      role: roles/iap.httpsResourceAccessor
      member: user:jane@example.com

The member property identifies who gets access using formats like “user:jane@example.com” for Google accounts or “serviceAccount:…” for service accounts. The role property specifies what they can do; “roles/iap.httpsResourceAccessor” allows HTTPS access through IAP. The service, appId, and project properties identify which App Engine service to protect. This non-authoritative approach preserves existing members with the same role.

Add time-limited access with IAM Conditions

Teams granting temporary access for contractors or time-bound projects can use IAM Conditions to set automatic expiration dates.

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

const member = new gcp.iap.AppEngineServiceIamMember("member", {
    project: version.project,
    appId: version.project,
    service: version.service,
    role: "roles/iap.httpsResourceAccessor",
    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.iap.AppEngineServiceIamMember("member",
    project=version["project"],
    app_id=version["project"],
    service=version["service"],
    role="roles/iap.httpsResourceAccessor",
    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/iap"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := iap.NewAppEngineServiceIamMember(ctx, "member", &iap.AppEngineServiceIamMemberArgs{
			Project: pulumi.Any(version.Project),
			AppId:   pulumi.Any(version.Project),
			Service: pulumi.Any(version.Service),
			Role:    pulumi.String("roles/iap.httpsResourceAccessor"),
			Member:  pulumi.String("user:jane@example.com"),
			Condition: &iap.AppEngineServiceIamMemberConditionArgs{
				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.Iap.AppEngineServiceIamMember("member", new()
    {
        Project = version.Project,
        AppId = version.Project,
        Service = version.Service,
        Role = "roles/iap.httpsResourceAccessor",
        Member = "user:jane@example.com",
        Condition = new Gcp.Iap.Inputs.AppEngineServiceIamMemberConditionArgs
        {
            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.AppEngineServiceIamMember;
import com.pulumi.gcp.iap.AppEngineServiceIamMemberArgs;
import com.pulumi.gcp.iap.inputs.AppEngineServiceIamMemberConditionArgs;
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 AppEngineServiceIamMember("member", AppEngineServiceIamMemberArgs.builder()
            .project(version.project())
            .appId(version.project())
            .service(version.service())
            .role("roles/iap.httpsResourceAccessor")
            .member("user:jane@example.com")
            .condition(AppEngineServiceIamMemberConditionArgs.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:iap:AppEngineServiceIamMember
    properties:
      project: ${version.project}
      appId: ${version.project}
      service: ${version.service}
      role: roles/iap.httpsResourceAccessor
      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 constraints to the permission grant. The expression property uses CEL (Common Expression Language) to define when access is valid; here, “request.time < timestamp(…)” expires access at midnight on 2020-01-01. The title and description properties document the condition’s purpose. IAM Conditions have some limitations documented in Google Cloud’s IAM Conditions overview.

Grant a role to multiple users at once

When multiple users need identical permissions, binding a role to a list of members is more efficient than creating separate member resources.

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

const binding = new gcp.iap.AppEngineServiceIamBinding("binding", {
    project: version.project,
    appId: version.project,
    service: version.service,
    role: "roles/iap.httpsResourceAccessor",
    members: ["user:jane@example.com"],
});

import pulumi
import pulumi_gcp as gcp

binding = gcp.iap.AppEngineServiceIamBinding("binding",
    project=version["project"],
    app_id=version["project"],
    service=version["service"],
    role="roles/iap.httpsResourceAccessor",
    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.NewAppEngineServiceIamBinding(ctx, "binding", &iap.AppEngineServiceIamBindingArgs{
			Project: pulumi.Any(version.Project),
			AppId:   pulumi.Any(version.Project),
			Service: pulumi.Any(version.Service),
			Role:    pulumi.String("roles/iap.httpsResourceAccessor"),
			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.AppEngineServiceIamBinding("binding", new()
    {
        Project = version.Project,
        AppId = version.Project,
        Service = version.Service,
        Role = "roles/iap.httpsResourceAccessor",
        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.AppEngineServiceIamBinding;
import com.pulumi.gcp.iap.AppEngineServiceIamBindingArgs;
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 AppEngineServiceIamBinding("binding", AppEngineServiceIamBindingArgs.builder()
            .project(version.project())
            .appId(version.project())
            .service(version.service())
            .role("roles/iap.httpsResourceAccessor")
            .members("user:jane@example.com")
            .build());

    }
}

resources:
  binding:
    type: gcp:iap:AppEngineServiceIamBinding
    properties:
      project: ${version.project}
      appId: ${version.project}
      service: ${version.service}
      role: roles/iap.httpsResourceAccessor
      members:
        - user:jane@example.com

The AppEngineServiceIamBinding resource grants a role to multiple members simultaneously. The members property takes an array of identity strings. This resource is authoritative for the specified role: it replaces all members for that role but preserves other roles on the service. You can combine AppEngineServiceIamBinding and AppEngineServiceIamMember resources as long as they don’t grant the same role.

Beyond these examples

These snippets focus on specific IAM grant features: single-member and multi-member IAM grants, and time-based access with IAM Conditions. They’re intentionally minimal rather than full access control configurations.

The examples reference pre-existing infrastructure such as App Engine applications and services, and assume IAP is already enabled on the application. They focus on granting access rather than provisioning the underlying App Engine infrastructure.

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

Full policy replacement (AppEngineServiceIamPolicy)
Federated identity and workload identity principals
Custom role definitions
Audit logging and access monitoring

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

Let's manage GCP App Engine IAP Service 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

What's the difference between AppEngineServiceIamPolicy, Binding, and Member?

Three resources manage IAM policies with different levels of control:

AppEngineServiceIamPolicy is authoritative and replaces the entire IAM policy
AppEngineServiceIamBinding is authoritative for a specific role, managing all members for that role
AppEngineServiceIamMember is non-authoritative, adding individual members without affecting other members

Can I use AppEngineServiceIamPolicy with Binding or Member resources?

No, AppEngineServiceIamPolicy cannot be used with AppEngineServiceIamBinding or AppEngineServiceIamMember as they will conflict over the policy configuration.

Can I use AppEngineServiceIamBinding and AppEngineServiceIamMember together?

Yes, but only if they don’t grant privileges to the same role. Each role must be managed by only one resource type.

Which IAM resource should I use for my use case?

Use AppEngineServiceIamPolicy when you need full control over the entire policy. Use AppEngineServiceIamBinding to manage all members for specific roles. Use AppEngineServiceIamMember to add individual members without affecting existing access.

IAM Configuration

What member identity formats are supported?

The member property supports multiple identity 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:// format for workload/workforce identity pools

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.

How do I add time-based access with IAM Conditions?

Use the condition property with a title, description, and expression. For example, set expression to request.time < timestamp("2020-01-01T00:00:00Z") for access expiring at a specific time.

Limitations & Behavior

What are the known limitations of IAM Conditions?

IAM Conditions are supported but have documented limitations. Review the GCP IAM Conditions limitations documentation if you encounter issues.

What properties can't be changed after creation?

All core properties are immutable: appId, member, project, role, service, and condition. Changes to these properties require recreating the resource.

Using a different cloud?

Explore iam guides for other cloud providers:

AWS Guides Azure Guides