Manage GCP Cloud Storage Managed Folder IAM Access

The gcp:storage/managedFolderIamMember:ManagedFolderIamMember resource, part of the Pulumi GCP provider, grants IAM roles to individual members on Cloud Storage managed folders without affecting other role assignments. This guide focuses on three capabilities: single-member role grants, multi-member role bindings, and time-based access with IAM Conditions.

Managed folder IAM resources reference existing folders within Cloud Storage buckets. The examples are intentionally small. Combine them with your own bucket and folder infrastructure.

Grant a role to a single member

When you need to give one user or service account access to a managed folder, ManagedFolderIamMember adds that member without affecting other existing permissions.

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

const member = new gcp.storage.ManagedFolderIamMember("member", {
    bucket: folder.bucket,
    managedFolder: folder.name,
    role: "roles/storage.admin",
    member: "user:jane@example.com",
});

import pulumi
import pulumi_gcp as gcp

member = gcp.storage.ManagedFolderIamMember("member",
    bucket=folder["bucket"],
    managed_folder=folder["name"],
    role="roles/storage.admin",
    member="user:jane@example.com")

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/storage"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := storage.NewManagedFolderIamMember(ctx, "member", &storage.ManagedFolderIamMemberArgs{
			Bucket:        pulumi.Any(folder.Bucket),
			ManagedFolder: pulumi.Any(folder.Name),
			Role:          pulumi.String("roles/storage.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.Storage.ManagedFolderIamMember("member", new()
    {
        Bucket = folder.Bucket,
        ManagedFolder = folder.Name,
        Role = "roles/storage.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.storage.ManagedFolderIamMember;
import com.pulumi.gcp.storage.ManagedFolderIamMemberArgs;
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 ManagedFolderIamMember("member", ManagedFolderIamMemberArgs.builder()
            .bucket(folder.bucket())
            .managedFolder(folder.name())
            .role("roles/storage.admin")
            .member("user:jane@example.com")
            .build());

    }
}

resources:
  member:
    type: gcp:storage:ManagedFolderIamMember
    properties:
      bucket: ${folder.bucket}
      managedFolder: ${folder.name}
      role: roles/storage.admin
      member: user:jane@example.com

The member property identifies who receives access, using formats like “user:jane@example.com” or “serviceAccount:app@project.iam.gserviceaccount.com”. The role property specifies the permission level. This resource is non-authoritative: it adds the member to the role without removing other members who already have that role.

Grant time-limited access with IAM Conditions

IAM Conditions let you grant temporary access that expires automatically, useful for contractors or time-bound projects.

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

const member = new gcp.storage.ManagedFolderIamMember("member", {
    bucket: folder.bucket,
    managedFolder: folder.name,
    role: "roles/storage.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.storage.ManagedFolderIamMember("member",
    bucket=folder["bucket"],
    managed_folder=folder["name"],
    role="roles/storage.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/storage"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := storage.NewManagedFolderIamMember(ctx, "member", &storage.ManagedFolderIamMemberArgs{
			Bucket:        pulumi.Any(folder.Bucket),
			ManagedFolder: pulumi.Any(folder.Name),
			Role:          pulumi.String("roles/storage.admin"),
			Member:        pulumi.String("user:jane@example.com"),
			Condition: &storage.ManagedFolderIamMemberConditionArgs{
				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.Storage.ManagedFolderIamMember("member", new()
    {
        Bucket = folder.Bucket,
        ManagedFolder = folder.Name,
        Role = "roles/storage.admin",
        Member = "user:jane@example.com",
        Condition = new Gcp.Storage.Inputs.ManagedFolderIamMemberConditionArgs
        {
            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.storage.ManagedFolderIamMember;
import com.pulumi.gcp.storage.ManagedFolderIamMemberArgs;
import com.pulumi.gcp.storage.inputs.ManagedFolderIamMemberConditionArgs;
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 ManagedFolderIamMember("member", ManagedFolderIamMemberArgs.builder()
            .bucket(folder.bucket())
            .managedFolder(folder.name())
            .role("roles/storage.admin")
            .member("user:jane@example.com")
            .condition(ManagedFolderIamMemberConditionArgs.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:storage:ManagedFolderIamMember
    properties:
      bucket: ${folder.bucket}
      managedFolder: ${folder.name}
      role: roles/storage.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 constraints to the role grant. The expression property uses CEL (Common Expression Language) to define when access is valid. Here, the timestamp comparison ensures access expires at midnight on 2020-01-01. The title and description properties document the condition’s purpose.

Bind a role to multiple members at once

When multiple users or service accounts need the same permissions, ManagedFolderIamBinding grants a role to all of them in one resource.

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

const binding = new gcp.storage.ManagedFolderIamBinding("binding", {
    bucket: folder.bucket,
    managedFolder: folder.name,
    role: "roles/storage.admin",
    members: ["user:jane@example.com"],
});

import pulumi
import pulumi_gcp as gcp

binding = gcp.storage.ManagedFolderIamBinding("binding",
    bucket=folder["bucket"],
    managed_folder=folder["name"],
    role="roles/storage.admin",
    members=["user:jane@example.com"])

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/storage"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := storage.NewManagedFolderIamBinding(ctx, "binding", &storage.ManagedFolderIamBindingArgs{
			Bucket:        pulumi.Any(folder.Bucket),
			ManagedFolder: pulumi.Any(folder.Name),
			Role:          pulumi.String("roles/storage.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.Storage.ManagedFolderIamBinding("binding", new()
    {
        Bucket = folder.Bucket,
        ManagedFolder = folder.Name,
        Role = "roles/storage.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.storage.ManagedFolderIamBinding;
import com.pulumi.gcp.storage.ManagedFolderIamBindingArgs;
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 ManagedFolderIamBinding("binding", ManagedFolderIamBindingArgs.builder()
            .bucket(folder.bucket())
            .managedFolder(folder.name())
            .role("roles/storage.admin")
            .members("user:jane@example.com")
            .build());

    }
}

resources:
  binding:
    type: gcp:storage:ManagedFolderIamBinding
    properties:
      bucket: ${folder.bucket}
      managedFolder: ${folder.name}
      role: roles/storage.admin
      members:
        - user:jane@example.com

The members property takes a list of identities who will receive the role. This resource is authoritative for the specified role: it replaces the complete member list for that role. Use ManagedFolderIamMember instead if you need to add members incrementally without affecting others.

Beyond these examples

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

The examples reference pre-existing infrastructure such as Cloud Storage buckets with managed folders. They focus on granting access rather than provisioning the storage resources themselves.

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

Full policy replacement (ManagedFolderIamPolicy)
Custom role formatting ([projects|organizations]/{parent}/roles/{name})
Special member identifiers (allUsers, allAuthenticatedUsers, domain:, projectOwner:)
Condition expressions beyond time-based expiration

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

Let's manage GCP Cloud Storage Managed Folder IAM Access

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 managed folders?

You have three options:

ManagedFolderIamPolicy - Authoritative control of the entire IAM policy (replaces existing policy)
ManagedFolderIamBinding - Authoritative control of all members for a specific role (preserves other roles)
ManagedFolderIamMember - Non-authoritative addition of individual members (preserves other members for the role)

Can I mix ManagedFolderIamPolicy with other IAM resources?

No, ManagedFolderIamPolicy cannot be used with ManagedFolderIamBinding or ManagedFolderIamMember because they will conflict over the policy configuration.

Can I use ManagedFolderIamBinding and ManagedFolderIamMember together?

Yes, but only if they don’t grant privileges to the same role. Each role must be managed by either Binding or Member resources, not both.

IAM Configuration

What member identity formats are supported?

Supported formats include allUsers, allAuthenticatedUsers, user:{email}, serviceAccount:{email}, group:{email}, domain:{domain}, and project-based identities like projectOwner:{projectid}, projectEditor:{projectid}, and projectViewer:{projectid}.

How do I specify custom roles?

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

How do I add time-based access restrictions?

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

What limitations exist for IAM Conditions?

IAM Conditions are supported but have known limitations. These limitations may affect certain use cases, so review the constraints before implementing conditions.

Resource Lifecycle

What properties can't be changed after creation?

All properties are immutable: bucket, managedFolder, member, role, and condition. Any changes require recreating the resource.

Using a different cloud?

Explore security guides for other cloud providers:

AWS Guides Azure Guides