Manage GCP Container Analysis Note IAM Policies

The gcp:containeranalysis/noteIamPolicy:NoteIamPolicy resource, part of the Pulumi GCP provider, manages IAM access control for Container Analysis notes, which store vulnerability and compliance metadata. This guide focuses on three approaches: authoritative policy replacement (NoteIamPolicy), role-level member management (NoteIamBinding), and individual member grants (NoteIamMember).

These resources reference existing Container Analysis notes and require the Container Analysis API to be enabled. The examples are intentionally small. Combine them with your own note resources and access requirements. Note that NoteIamPolicy cannot be used alongside NoteIamBinding or NoteIamMember, as they will conflict over policy ownership.

Replace the entire IAM policy for a note

When you need complete control over who can access a Container Analysis note, 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/containeranalysis.notes.occurrences.viewer",
        members: ["user:jane@example.com"],
    }],
});
const policy = new gcp.containeranalysis.NoteIamPolicy("policy", {
    project: note.project,
    note: note.name,
    policyData: admin.then(admin => admin.policyData),
});

import pulumi
import pulumi_gcp as gcp

admin = gcp.organizations.get_iam_policy(bindings=[{
    "role": "roles/containeranalysis.notes.occurrences.viewer",
    "members": ["user:jane@example.com"],
}])
policy = gcp.containeranalysis.NoteIamPolicy("policy",
    project=note["project"],
    note=note["name"],
    policy_data=admin.policy_data)

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/containeranalysis"
	"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/containeranalysis.notes.occurrences.viewer",
					Members: []string{
						"user:jane@example.com",
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		_, err = containeranalysis.NewNoteIamPolicy(ctx, "policy", &containeranalysis.NoteIamPolicyArgs{
			Project:    pulumi.Any(note.Project),
			Note:       pulumi.Any(note.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/containeranalysis.notes.occurrences.viewer",
                Members = new[]
                {
                    "user:jane@example.com",
                },
            },
        },
    });

    var policy = new Gcp.ContainerAnalysis.NoteIamPolicy("policy", new()
    {
        Project = note.Project,
        Note = note.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.containeranalysis.NoteIamPolicy;
import com.pulumi.gcp.containeranalysis.NoteIamPolicyArgs;
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/containeranalysis.notes.occurrences.viewer")
                .members("user:jane@example.com")
                .build())
            .build());

        var policy = new NoteIamPolicy("policy", NoteIamPolicyArgs.builder()
            .project(note.project())
            .note(note.name())
            .policyData(admin.policyData())
            .build());

    }
}

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

The NoteIamPolicy resource is authoritative: it replaces the entire IAM policy for the note. The policyData property comes from the getIAMPolicy data source, which defines bindings between roles and members. This approach gives you full control but overwrites any permissions not declared in your policy.

Grant a role to multiple members at once

When multiple users or service accounts need the same level of access to a note, you can bind them all to a single role without affecting other role assignments.

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

const binding = new gcp.containeranalysis.NoteIamBinding("binding", {
    project: note.project,
    note: note.name,
    role: "roles/containeranalysis.notes.occurrences.viewer",
    members: ["user:jane@example.com"],
});

import pulumi
import pulumi_gcp as gcp

binding = gcp.containeranalysis.NoteIamBinding("binding",
    project=note["project"],
    note=note["name"],
    role="roles/containeranalysis.notes.occurrences.viewer",
    members=["user:jane@example.com"])

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := containeranalysis.NewNoteIamBinding(ctx, "binding", &containeranalysis.NoteIamBindingArgs{
			Project: pulumi.Any(note.Project),
			Note:    pulumi.Any(note.Name),
			Role:    pulumi.String("roles/containeranalysis.notes.occurrences.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.ContainerAnalysis.NoteIamBinding("binding", new()
    {
        Project = note.Project,
        Note = note.Name,
        Role = "roles/containeranalysis.notes.occurrences.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.containeranalysis.NoteIamBinding;
import com.pulumi.gcp.containeranalysis.NoteIamBindingArgs;
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 NoteIamBinding("binding", NoteIamBindingArgs.builder()
            .project(note.project())
            .note(note.name())
            .role("roles/containeranalysis.notes.occurrences.viewer")
            .members("user:jane@example.com")
            .build());

    }
}

resources:
  binding:
    type: gcp:containeranalysis:NoteIamBinding
    properties:
      project: ${note.project}
      note: ${note.name}
      role: roles/containeranalysis.notes.occurrences.viewer
      members:
        - user:jane@example.com

The NoteIamBinding resource is authoritative for a single role: it replaces all members for that role but preserves other roles in the policy. The members property accepts a list of identities (users, service accounts, groups). This approach works well when you manage all members for a role together.

Add a single member to a role incrementally

When you need to grant access to one user or service account without disturbing existing permissions, you can add individual members to roles.

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

const member = new gcp.containeranalysis.NoteIamMember("member", {
    project: note.project,
    note: note.name,
    role: "roles/containeranalysis.notes.occurrences.viewer",
    member: "user:jane@example.com",
});

import pulumi
import pulumi_gcp as gcp

member = gcp.containeranalysis.NoteIamMember("member",
    project=note["project"],
    note=note["name"],
    role="roles/containeranalysis.notes.occurrences.viewer",
    member="user:jane@example.com")

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := containeranalysis.NewNoteIamMember(ctx, "member", &containeranalysis.NoteIamMemberArgs{
			Project: pulumi.Any(note.Project),
			Note:    pulumi.Any(note.Name),
			Role:    pulumi.String("roles/containeranalysis.notes.occurrences.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.ContainerAnalysis.NoteIamMember("member", new()
    {
        Project = note.Project,
        Note = note.Name,
        Role = "roles/containeranalysis.notes.occurrences.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.containeranalysis.NoteIamMember;
import com.pulumi.gcp.containeranalysis.NoteIamMemberArgs;
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 NoteIamMember("member", NoteIamMemberArgs.builder()
            .project(note.project())
            .note(note.name())
            .role("roles/containeranalysis.notes.occurrences.viewer")
            .member("user:jane@example.com")
            .build());

    }
}

resources:
  member:
    type: gcp:containeranalysis:NoteIamMember
    properties:
      project: ${note.project}
      note: ${note.name}
      role: roles/containeranalysis.notes.occurrences.viewer
      member: user:jane@example.com

The NoteIamMember resource is non-authoritative: it adds one member to a role without affecting other members or roles. The member property accepts a single identity. This approach works well for incremental access grants or when multiple teams manage access independently.

Beyond these examples

These snippets focus on specific IAM management approaches: authoritative vs non-authoritative IAM management and role-based access control for Container Analysis notes. They’re intentionally minimal rather than full access control configurations.

The examples reference pre-existing infrastructure such as Container Analysis notes (gcp.containeranalysis.Note) and a GCP project with Container Analysis API enabled. They focus on IAM policy configuration rather than provisioning the underlying notes.

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

Conditional IAM bindings (conditions)
Custom IAM roles
Service account impersonation
IAM policy retrieval (data source usage)

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

Let's manage GCP Container Analysis Note 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

Can I use NoteIamPolicy with NoteIamBinding or NoteIamMember?

No, gcp.containeranalysis.NoteIamPolicy cannot be used with gcp.containeranalysis.NoteIamBinding or gcp.containeranalysis.NoteIamMember because they will conflict over policy management.

Can I use NoteIamBinding and NoteIamMember 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 managing Container Registry Note permissions?

Choose based on your needs:

NoteIamPolicy - Full policy control, replaces entire policy (authoritative)
NoteIamBinding - Manage all members for a specific role (authoritative for that role)
NoteIamMember - Add individual members without affecting others (non-authoritative)

Configuration & Properties

What properties can't be changed after creation?

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

How do I generate the policyData for NoteIamPolicy?

Use the gcp.organizations.getIAMPolicy data source to generate the policy data, as shown in the examples.

Import & Management

What formats can I use when importing a NoteIamPolicy?

Three formats are supported:

projects/{{project}}/notes/{{name}}
{{project}}/{{name}}
{{name}}

Any variables not provided in the import command will be taken from the provider configuration.

Using a different cloud?

Explore security guides for other cloud providers:

AWS Guides Azure Guides