Manage GCP Compute Storage Pool IAM Policies

The gcp:compute/storagePoolIamPolicy:StoragePoolIamPolicy resource, part of the Pulumi GCP provider, manages IAM access control for Compute Engine storage pools using three distinct approaches: authoritative policy replacement (StoragePoolIamPolicy), role-level member binding (StoragePoolIamBinding), and individual member grants (StoragePoolIamMember). This guide focuses on four capabilities: authoritative policy management, role-level bindings, individual member grants, and time-limited access with IAM Conditions.

These resources reference existing storage pools by project, zone, and name. StoragePoolIamPolicy cannot be used alongside StoragePoolIamBinding or StoragePoolIamMember on the same storage pool, as they conflict over policy ownership. The examples are intentionally small. Choose the resource type that matches your access control needs.

Replace the entire IAM policy for a storage pool

When you need complete control over who can access a storage pool, you can set the entire IAM policy at once, replacing any existing permissions.

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

const admin = gcp.organizations.getIAMPolicy({
    bindings: [{
        role: "roles/compute.viewer",
        members: ["user:jane@example.com"],
    }],
});
const policy = new gcp.compute.StoragePoolIamPolicy("policy", {
    project: test_storage_pool_basic.project,
    zone: test_storage_pool_basic.zone,
    name: test_storage_pool_basic.name,
    policyData: admin.then(admin => admin.policyData),
});

import pulumi
import pulumi_gcp as gcp

admin = gcp.organizations.get_iam_policy(bindings=[{
    "role": "roles/compute.viewer",
    "members": ["user:jane@example.com"],
}])
policy = gcp.compute.StoragePoolIamPolicy("policy",
    project=test_storage_pool_basic["project"],
    zone=test_storage_pool_basic["zone"],
    name=test_storage_pool_basic["name"],
    policy_data=admin.policy_data)

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		admin, err := organizations.LookupIAMPolicy(ctx, &organizations.LookupIAMPolicyArgs{
			Bindings: []organizations.GetIAMPolicyBinding{
				{
					Role: "roles/compute.viewer",
					Members: []string{
						"user:jane@example.com",
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		_, err = compute.NewStoragePoolIamPolicy(ctx, "policy", &compute.StoragePoolIamPolicyArgs{
			Project:    pulumi.Any(test_storage_pool_basic.Project),
			Zone:       pulumi.Any(test_storage_pool_basic.Zone),
			Name:       pulumi.Any(test_storage_pool_basic.Name),
			PolicyData: pulumi.String(admin.PolicyData),
		})
		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 admin = Gcp.Organizations.GetIAMPolicy.Invoke(new()
    {
        Bindings = new[]
        {
            new Gcp.Organizations.Inputs.GetIAMPolicyBindingInputArgs
            {
                Role = "roles/compute.viewer",
                Members = new[]
                {
                    "user:jane@example.com",
                },
            },
        },
    });

    var policy = new Gcp.Compute.StoragePoolIamPolicy("policy", new()
    {
        Project = test_storage_pool_basic.Project,
        Zone = test_storage_pool_basic.Zone,
        Name = test_storage_pool_basic.Name,
        PolicyData = admin.Apply(getIAMPolicyResult => getIAMPolicyResult.PolicyData),
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.organizations.OrganizationsFunctions;
import com.pulumi.gcp.organizations.inputs.GetIAMPolicyArgs;
import com.pulumi.gcp.compute.StoragePoolIamPolicy;
import com.pulumi.gcp.compute.StoragePoolIamPolicyArgs;
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) {
        final var admin = OrganizationsFunctions.getIAMPolicy(GetIAMPolicyArgs.builder()
            .bindings(GetIAMPolicyBindingArgs.builder()
                .role("roles/compute.viewer")
                .members("user:jane@example.com")
                .build())
            .build());

        var policy = new StoragePoolIamPolicy("policy", StoragePoolIamPolicyArgs.builder()
            .project(test_storage_pool_basic.project())
            .zone(test_storage_pool_basic.zone())
            .name(test_storage_pool_basic.name())
            .policyData(admin.policyData())
            .build());

    }
}

resources:
  policy:
    type: gcp:compute:StoragePoolIamPolicy
    properties:
      project: ${["test-storage-pool-basic"].project}
      zone: ${["test-storage-pool-basic"].zone}
      name: ${["test-storage-pool-basic"].name}
      policyData: ${admin.policyData}
variables:
  admin:
    fn::invoke:
      function: gcp:organizations:getIAMPolicy
      arguments:
        bindings:
          - role: roles/compute.viewer
            members:
              - user:jane@example.com

StoragePoolIamPolicy is authoritative: it replaces the entire IAM policy for the storage pool. The policyData comes from the getIAMPolicy data source, which defines bindings between roles and members. The project, zone, and name properties identify which storage pool to manage.

Set 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 admin = gcp.organizations.getIAMPolicy({
    bindings: [{
        role: "roles/compute.viewer",
        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\")",
        },
    }],
});
const policy = new gcp.compute.StoragePoolIamPolicy("policy", {
    project: test_storage_pool_basic.project,
    zone: test_storage_pool_basic.zone,
    name: test_storage_pool_basic.name,
    policyData: admin.then(admin => admin.policyData),
});

import pulumi
import pulumi_gcp as gcp

admin = gcp.organizations.get_iam_policy(bindings=[{
    "role": "roles/compute.viewer",
    "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\")",
    },
}])
policy = gcp.compute.StoragePoolIamPolicy("policy",
    project=test_storage_pool_basic["project"],
    zone=test_storage_pool_basic["zone"],
    name=test_storage_pool_basic["name"],
    policy_data=admin.policy_data)

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		admin, err := organizations.LookupIAMPolicy(ctx, &organizations.LookupIAMPolicyArgs{
			Bindings: []organizations.GetIAMPolicyBinding{
				{
					Role: "roles/compute.viewer",
					Members: []string{
						"user:jane@example.com",
					},
					Condition: {
						Title:       "expires_after_2019_12_31",
						Description: pulumi.StringRef("Expiring at midnight of 2019-12-31"),
						Expression:  "request.time < timestamp(\"2020-01-01T00:00:00Z\")",
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		_, err = compute.NewStoragePoolIamPolicy(ctx, "policy", &compute.StoragePoolIamPolicyArgs{
			Project:    pulumi.Any(test_storage_pool_basic.Project),
			Zone:       pulumi.Any(test_storage_pool_basic.Zone),
			Name:       pulumi.Any(test_storage_pool_basic.Name),
			PolicyData: pulumi.String(admin.PolicyData),
		})
		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 admin = Gcp.Organizations.GetIAMPolicy.Invoke(new()
    {
        Bindings = new[]
        {
            new Gcp.Organizations.Inputs.GetIAMPolicyBindingInputArgs
            {
                Role = "roles/compute.viewer",
                Members = new[]
                {
                    "user:jane@example.com",
                },
                Condition = new Gcp.Organizations.Inputs.GetIAMPolicyBindingConditionInputArgs
                {
                    Title = "expires_after_2019_12_31",
                    Description = "Expiring at midnight of 2019-12-31",
                    Expression = "request.time < timestamp(\"2020-01-01T00:00:00Z\")",
                },
            },
        },
    });

    var policy = new Gcp.Compute.StoragePoolIamPolicy("policy", new()
    {
        Project = test_storage_pool_basic.Project,
        Zone = test_storage_pool_basic.Zone,
        Name = test_storage_pool_basic.Name,
        PolicyData = admin.Apply(getIAMPolicyResult => getIAMPolicyResult.PolicyData),
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.organizations.OrganizationsFunctions;
import com.pulumi.gcp.organizations.inputs.GetIAMPolicyArgs;
import com.pulumi.gcp.compute.StoragePoolIamPolicy;
import com.pulumi.gcp.compute.StoragePoolIamPolicyArgs;
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) {
        final var admin = OrganizationsFunctions.getIAMPolicy(GetIAMPolicyArgs.builder()
            .bindings(GetIAMPolicyBindingArgs.builder()
                .role("roles/compute.viewer")
                .members("user:jane@example.com")
                .condition(GetIAMPolicyBindingConditionArgs.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())
            .build());

        var policy = new StoragePoolIamPolicy("policy", StoragePoolIamPolicyArgs.builder()
            .project(test_storage_pool_basic.project())
            .zone(test_storage_pool_basic.zone())
            .name(test_storage_pool_basic.name())
            .policyData(admin.policyData())
            .build());

    }
}

resources:
  policy:
    type: gcp:compute:StoragePoolIamPolicy
    properties:
      project: ${["test-storage-pool-basic"].project}
      zone: ${["test-storage-pool-basic"].zone}
      name: ${["test-storage-pool-basic"].name}
      policyData: ${admin.policyData}
variables:
  admin:
    fn::invoke:
      function: gcp:organizations:getIAMPolicy
      arguments:
        bindings:
          - role: roles/compute.viewer
            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")

The condition block adds time-based restrictions to role bindings. The expression uses CEL (Common Expression Language) to compare request.time against a timestamp. When the condition evaluates to false, access is denied even if the role binding exists. The title and description document the condition’s purpose.

Grant a role to multiple members with binding

When multiple users or service accounts need the same role, StoragePoolIamBinding manages them as a group while preserving other roles on the storage pool.

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

const binding = new gcp.compute.StoragePoolIamBinding("binding", {
    project: test_storage_pool_basic.project,
    zone: test_storage_pool_basic.zone,
    name: test_storage_pool_basic.name,
    role: "roles/compute.viewer",
    members: ["user:jane@example.com"],
});

import pulumi
import pulumi_gcp as gcp

binding = gcp.compute.StoragePoolIamBinding("binding",
    project=test_storage_pool_basic["project"],
    zone=test_storage_pool_basic["zone"],
    name=test_storage_pool_basic["name"],
    role="roles/compute.viewer",
    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.NewStoragePoolIamBinding(ctx, "binding", &compute.StoragePoolIamBindingArgs{
			Project: pulumi.Any(test_storage_pool_basic.Project),
			Zone:    pulumi.Any(test_storage_pool_basic.Zone),
			Name:    pulumi.Any(test_storage_pool_basic.Name),
			Role:    pulumi.String("roles/compute.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.Compute.StoragePoolIamBinding("binding", new()
    {
        Project = test_storage_pool_basic.Project,
        Zone = test_storage_pool_basic.Zone,
        Name = test_storage_pool_basic.Name,
        Role = "roles/compute.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.compute.StoragePoolIamBinding;
import com.pulumi.gcp.compute.StoragePoolIamBindingArgs;
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 StoragePoolIamBinding("binding", StoragePoolIamBindingArgs.builder()
            .project(test_storage_pool_basic.project())
            .zone(test_storage_pool_basic.zone())
            .name(test_storage_pool_basic.name())
            .role("roles/compute.viewer")
            .members("user:jane@example.com")
            .build());

    }
}

resources:
  binding:
    type: gcp:compute:StoragePoolIamBinding
    properties:
      project: ${["test-storage-pool-basic"].project}
      zone: ${["test-storage-pool-basic"].zone}
      name: ${["test-storage-pool-basic"].name}
      role: roles/compute.viewer
      members:
        - user:jane@example.com

StoragePoolIamBinding is authoritative for a single role: it controls the complete list of members for that role but doesn’t affect other roles. The members property takes an array of identity strings (users, service accounts, groups). This approach works well when you manage all members for a role together.

Add a single member without affecting others

StoragePoolIamMember adds one identity to a role without changing other members who already have that role or other roles on the storage pool.

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

const member = new gcp.compute.StoragePoolIamMember("member", {
    project: test_storage_pool_basic.project,
    zone: test_storage_pool_basic.zone,
    name: test_storage_pool_basic.name,
    role: "roles/compute.viewer",
    member: "user:jane@example.com",
});

import pulumi
import pulumi_gcp as gcp

member = gcp.compute.StoragePoolIamMember("member",
    project=test_storage_pool_basic["project"],
    zone=test_storage_pool_basic["zone"],
    name=test_storage_pool_basic["name"],
    role="roles/compute.viewer",
    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.NewStoragePoolIamMember(ctx, "member", &compute.StoragePoolIamMemberArgs{
			Project: pulumi.Any(test_storage_pool_basic.Project),
			Zone:    pulumi.Any(test_storage_pool_basic.Zone),
			Name:    pulumi.Any(test_storage_pool_basic.Name),
			Role:    pulumi.String("roles/compute.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.Compute.StoragePoolIamMember("member", new()
    {
        Project = test_storage_pool_basic.Project,
        Zone = test_storage_pool_basic.Zone,
        Name = test_storage_pool_basic.Name,
        Role = "roles/compute.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.compute.StoragePoolIamMember;
import com.pulumi.gcp.compute.StoragePoolIamMemberArgs;
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 StoragePoolIamMember("member", StoragePoolIamMemberArgs.builder()
            .project(test_storage_pool_basic.project())
            .zone(test_storage_pool_basic.zone())
            .name(test_storage_pool_basic.name())
            .role("roles/compute.viewer")
            .member("user:jane@example.com")
            .build());

    }
}

resources:
  member:
    type: gcp:compute:StoragePoolIamMember
    properties:
      project: ${["test-storage-pool-basic"].project}
      zone: ${["test-storage-pool-basic"].zone}
      name: ${["test-storage-pool-basic"].name}
      role: roles/compute.viewer
      member: user:jane@example.com

StoragePoolIamMember is non-authoritative: it adds one member to a role without removing existing members. The member property takes a single identity string. This approach works well when different teams manage access independently, as each resource only controls its own grant.

Beyond these examples

These snippets focus on specific IAM management features: authoritative and non-authoritative IAM management, 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 storage pools (identified by project, zone, and name). They focus on configuring IAM access rather than provisioning the storage pools themselves.

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

Combining Policy with Binding or Member (causes conflicts)
Multiple Bindings or Members for the same role (causes conflicts)
IAM Condition limitations and edge cases
Custom role definitions and management

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

Let's manage GCP Compute Storage Pool IAM Policies

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: Policy, Binding, or Member?

Use StoragePoolIamPolicy to replace the entire IAM policy authoritatively. Use StoragePoolIamBinding to manage all members for a specific role while preserving other roles. Use StoragePoolIamMember to add individual members non-authoritatively, preserving other members for the role.

Can I use StoragePoolIamPolicy with StoragePoolIamBinding or StoragePoolIamMember?

No, StoragePoolIamPolicy cannot be used with StoragePoolIamBinding or StoragePoolIamMember because they will conflict over the policy configuration.

Can I use StoragePoolIamBinding and StoragePoolIamMember 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 Conditions

How do I add IAM Conditions to restrict access by time or other criteria?

Add a condition block with title, description, and expression fields to your StoragePoolIamBinding or StoragePoolIamMember resource. For example, use expression: "request.time < timestamp(\"2020-01-01T00:00:00Z\")" to expire access at a specific time.

Are there any limitations with IAM Conditions?

Yes, IAM Conditions have known limitations. If you encounter issues, review the GCP IAM Conditions limitations documentation.

Using a different cloud?

Explore security guides for other cloud providers:

AWS Guides Azure Guides