Manage GCP Compute Snapshot IAM Policies

The gcp:compute/snapshotIamPolicy:SnapshotIamPolicy resource, part of the Pulumi GCP provider, manages IAM permissions for Compute Engine snapshots using three distinct resources with different authoritativeness levels. This guide focuses on three capabilities: authoritative policy replacement (SnapshotIamPolicy), role-level member management (SnapshotIamBinding), and individual member grants (SnapshotIamMember).

All three resources reference existing snapshots by name and project. SnapshotIamPolicy replaces the entire policy, SnapshotIamBinding is authoritative for a single role, and SnapshotIamMember adds individual members non-authoritatively. The examples are intentionally small. Combine them with your own snapshot resources and IAM principals.

Replace the entire IAM policy for a snapshot

When you need complete control over snapshot access, replacing the entire IAM policy ensures no unexpected permissions remain.

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

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

import pulumi
import pulumi_gcp as gcp

admin = gcp.organizations.get_iam_policy(bindings=[{
    "role": "roles/viewer",
    "members": ["user:jane@example.com"],
}])
policy = gcp.compute.SnapshotIamPolicy("policy",
    project=snapshot["project"],
    name=snapshot["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/viewer",
					Members: []string{
						"user:jane@example.com",
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		_, err = compute.NewSnapshotIamPolicy(ctx, "policy", &compute.SnapshotIamPolicyArgs{
			Project:    pulumi.Any(snapshot.Project),
			Name:       pulumi.Any(snapshot.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/viewer",
                Members = new[]
                {
                    "user:jane@example.com",
                },
            },
        },
    });

    var policy = new Gcp.Compute.SnapshotIamPolicy("policy", new()
    {
        Project = snapshot.Project,
        Name = snapshot.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.SnapshotIamPolicy;
import com.pulumi.gcp.compute.SnapshotIamPolicyArgs;
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/viewer")
                .members("user:jane@example.com")
                .build())
            .build());

        var policy = new SnapshotIamPolicy("policy", SnapshotIamPolicyArgs.builder()
            .project(snapshot.project())
            .name(snapshot.name())
            .policyData(admin.policyData())
            .build());

    }
}

resources:
  policy:
    type: gcp:compute:SnapshotIamPolicy
    properties:
      project: ${snapshot.project}
      name: ${snapshot.name}
      policyData: ${admin.policyData}
variables:
  admin:
    fn::invoke:
      function: gcp:organizations:getIAMPolicy
      arguments:
        bindings:
          - role: roles/viewer
            members:
              - user:jane@example.com

The SnapshotIamPolicy resource sets the complete IAM policy using policyData from the getIAMPolicy data source. This approach is authoritative: it removes any existing bindings not included in the policy. The bindings array defines roles and their members.

Grant a role to multiple members at once

Teams often grant the same role to several users simultaneously, such as giving viewer access to an entire team.

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

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

import pulumi
import pulumi_gcp as gcp

binding = gcp.compute.SnapshotIamBinding("binding",
    project=snapshot["project"],
    name=snapshot["name"],
    role="roles/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.NewSnapshotIamBinding(ctx, "binding", &compute.SnapshotIamBindingArgs{
			Project: pulumi.Any(snapshot.Project),
			Name:    pulumi.Any(snapshot.Name),
			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.Compute.SnapshotIamBinding("binding", new()
    {
        Project = snapshot.Project,
        Name = snapshot.Name,
        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.compute.SnapshotIamBinding;
import com.pulumi.gcp.compute.SnapshotIamBindingArgs;
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 SnapshotIamBinding("binding", SnapshotIamBindingArgs.builder()
            .project(snapshot.project())
            .name(snapshot.name())
            .role("roles/viewer")
            .members("user:jane@example.com")
            .build());

    }
}

resources:
  binding:
    type: gcp:compute:SnapshotIamBinding
    properties:
      project: ${snapshot.project}
      name: ${snapshot.name}
      role: roles/viewer
      members:
        - user:jane@example.com

The SnapshotIamBinding resource manages all members for a specific role. It’s authoritative for that role only: other roles on the snapshot remain unchanged. The members array lists all principals who should have this role.

Add a single member to a role incrementally

When onboarding individual users, adding them one at a time avoids disrupting existing permissions.

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

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

import pulumi
import pulumi_gcp as gcp

member = gcp.compute.SnapshotIamMember("member",
    project=snapshot["project"],
    name=snapshot["name"],
    role="roles/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.NewSnapshotIamMember(ctx, "member", &compute.SnapshotIamMemberArgs{
			Project: pulumi.Any(snapshot.Project),
			Name:    pulumi.Any(snapshot.Name),
			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.Compute.SnapshotIamMember("member", new()
    {
        Project = snapshot.Project,
        Name = snapshot.Name,
        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.compute.SnapshotIamMember;
import com.pulumi.gcp.compute.SnapshotIamMemberArgs;
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 SnapshotIamMember("member", SnapshotIamMemberArgs.builder()
            .project(snapshot.project())
            .name(snapshot.name())
            .role("roles/viewer")
            .member("user:jane@example.com")
            .build());

    }
}

resources:
  member:
    type: gcp:compute:SnapshotIamMember
    properties:
      project: ${snapshot.project}
      name: ${snapshot.name}
      role: roles/viewer
      member: user:jane@example.com

The SnapshotIamMember resource grants a role to one member non-authoritatively. Other members with the same role are preserved. Use this when you need to add permissions without knowing or affecting the complete member list.

Beyond these examples

These snippets focus on specific IAM management approaches: authoritative vs non-authoritative IAM management, and policy-level, role-level, and member-level operations. They’re intentionally minimal rather than full access control configurations.

The examples reference pre-existing infrastructure such as Compute Engine snapshots (by name and project). They focus on IAM binding configuration rather than snapshot creation.

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

Conditional IAM bindings (condition property)
Audit logging configuration (auditConfigs)
Cross-project snapshot sharing
Service account impersonation

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

Let's manage GCP Compute Snapshot 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 for snapshot permissions?

Choose based on your needs:

SnapshotIamPolicy: Authoritative control of the entire IAM policy (replaces all existing permissions)
SnapshotIamBinding: Authoritative control of a specific role (preserves other roles)
SnapshotIamMember: Non-authoritative, adds individual members to a role (preserves other members)

What resources conflict with SnapshotIamPolicy?

SnapshotIamPolicy cannot be used with SnapshotIamBinding or SnapshotIamMember because they’ll compete to control the IAM policy. Use SnapshotIamPolicy alone, or use SnapshotIamBinding/SnapshotIamMember without it.

Can I use SnapshotIamBinding and SnapshotIamMember together?

Yes, but only if they grant different roles. Using both for the same role causes conflicts.

Configuration & Setup

How do I generate the policyData for SnapshotIamPolicy?

Use the gcp.organizations.getIAMPolicy data source with your desired bindings, then pass its policyData output to the SnapshotIamPolicy resource.

What properties are immutable after creation?

Both name and project are immutable and cannot be changed after the resource is created.

Import & Migration

How do I import a snapshot IAM resource with a custom role?

Use the full custom role name in the format [projects/my-project|organizations/my-org]/roles/my-custom-role when importing.

Using a different cloud?

Explore security guides for other cloud providers:

AWS Guides Azure Guides