Manage GCP Certificate Authority Pool IAM Bindings

The gcp:certificateauthority/caPoolIamBinding:CaPoolIamBinding resource, part of the Pulumi GCP provider, manages IAM role bindings for Certificate Authority Service CA Pools, controlling who can manage certificates and pool configuration. This guide focuses on three capabilities: authoritative role binding for multiple members, time-based conditional access, and non-authoritative member addition.

IAM bindings reference existing CA Pools and grant permissions to IAM principals that must exist in your GCP organization. The examples are intentionally small. Combine them with your own CA Pool resources and identity management.

Grant a role to multiple members at once

Teams managing CA Pool access often need to grant the same role to multiple users or service accounts simultaneously, ensuring consistent permissions across a group.

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

const binding = new gcp.certificateauthority.CaPoolIamBinding("binding", {
    caPool: _default.id,
    role: "roles/privateca.certificateManager",
    members: ["user:jane@example.com"],
});

import pulumi
import pulumi_gcp as gcp

binding = gcp.certificateauthority.CaPoolIamBinding("binding",
    ca_pool=default["id"],
    role="roles/privateca.certificateManager",
    members=["user:jane@example.com"])

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := certificateauthority.NewCaPoolIamBinding(ctx, "binding", &certificateauthority.CaPoolIamBindingArgs{
			CaPool: pulumi.Any(_default.Id),
			Role:   pulumi.String("roles/privateca.certificateManager"),
			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.CertificateAuthority.CaPoolIamBinding("binding", new()
    {
        CaPool = @default.Id,
        Role = "roles/privateca.certificateManager",
        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.certificateauthority.CaPoolIamBinding;
import com.pulumi.gcp.certificateauthority.CaPoolIamBindingArgs;
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 CaPoolIamBinding("binding", CaPoolIamBindingArgs.builder()
            .caPool(default_.id())
            .role("roles/privateca.certificateManager")
            .members("user:jane@example.com")
            .build());

    }
}

resources:
  binding:
    type: gcp:certificateauthority:CaPoolIamBinding
    properties:
      caPool: ${default.id}
      role: roles/privateca.certificateManager
      members:
        - user:jane@example.com

The CaPoolIamBinding resource is authoritative for the specified role, meaning it replaces all existing members for that role. The members array accepts various identity formats: user emails, service accounts, groups, and special identifiers like allAuthenticatedUsers. The caPool property references the pool to which permissions apply.

Add time-based access with IAM Conditions

Organizations implementing temporary access or compliance requirements can use IAM Conditions to automatically expire permissions at a specific date and time.

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

const binding = new gcp.certificateauthority.CaPoolIamBinding("binding", {
    caPool: _default.id,
    role: "roles/privateca.certificateManager",
    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\")",
    },
});

import pulumi
import pulumi_gcp as gcp

binding = gcp.certificateauthority.CaPoolIamBinding("binding",
    ca_pool=default["id"],
    role="roles/privateca.certificateManager",
    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\")",
    })

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := certificateauthority.NewCaPoolIamBinding(ctx, "binding", &certificateauthority.CaPoolIamBindingArgs{
			CaPool: pulumi.Any(_default.Id),
			Role:   pulumi.String("roles/privateca.certificateManager"),
			Members: pulumi.StringArray{
				pulumi.String("user:jane@example.com"),
			},
			Condition: &certificateauthority.CaPoolIamBindingConditionArgs{
				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 binding = new Gcp.CertificateAuthority.CaPoolIamBinding("binding", new()
    {
        CaPool = @default.Id,
        Role = "roles/privateca.certificateManager",
        Members = new[]
        {
            "user:jane@example.com",
        },
        Condition = new Gcp.CertificateAuthority.Inputs.CaPoolIamBindingConditionArgs
        {
            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.certificateauthority.CaPoolIamBinding;
import com.pulumi.gcp.certificateauthority.CaPoolIamBindingArgs;
import com.pulumi.gcp.certificateauthority.inputs.CaPoolIamBindingConditionArgs;
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 CaPoolIamBinding("binding", CaPoolIamBindingArgs.builder()
            .caPool(default_.id())
            .role("roles/privateca.certificateManager")
            .members("user:jane@example.com")
            .condition(CaPoolIamBindingConditionArgs.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:
  binding:
    type: gcp:certificateauthority:CaPoolIamBinding
    properties:
      caPool: ${default.id}
      role: roles/privateca.certificateManager
      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 a CEL expression that evaluates at request time. Here, the expression checks whether the current time is before midnight on January 1, 2020, automatically denying access after that timestamp. The title and description provide human-readable context for the condition. This extends the basic binding pattern with temporal access control.

Add a single member to an existing role

When you need to grant access to one additional user without affecting other members of the role, CaPoolIamMember provides non-authoritative updates that preserve existing bindings.

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

const member = new gcp.certificateauthority.CaPoolIamMember("member", {
    caPool: _default.id,
    role: "roles/privateca.certificateManager",
    member: "user:jane@example.com",
});

import pulumi
import pulumi_gcp as gcp

member = gcp.certificateauthority.CaPoolIamMember("member",
    ca_pool=default["id"],
    role="roles/privateca.certificateManager",
    member="user:jane@example.com")

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := certificateauthority.NewCaPoolIamMember(ctx, "member", &certificateauthority.CaPoolIamMemberArgs{
			CaPool: pulumi.Any(_default.Id),
			Role:   pulumi.String("roles/privateca.certificateManager"),
			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.CertificateAuthority.CaPoolIamMember("member", new()
    {
        CaPool = @default.Id,
        Role = "roles/privateca.certificateManager",
        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.certificateauthority.CaPoolIamMember;
import com.pulumi.gcp.certificateauthority.CaPoolIamMemberArgs;
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 CaPoolIamMember("member", CaPoolIamMemberArgs.builder()
            .caPool(default_.id())
            .role("roles/privateca.certificateManager")
            .member("user:jane@example.com")
            .build());

    }
}

resources:
  member:
    type: gcp:certificateauthority:CaPoolIamMember
    properties:
      caPool: ${default.id}
      role: roles/privateca.certificateManager
      member: user:jane@example.com

Unlike CaPoolIamBinding, CaPoolIamMember adds a single member to a role without replacing existing members. The member property accepts a single identity in the same formats as the members array. Use this when you want to incrementally grant access without managing the complete member list.

Beyond these examples

These snippets focus on specific IAM binding features: role binding with multiple members, time-based conditional access, and non-authoritative member addition. They’re intentionally minimal rather than full access control configurations.

The examples reference pre-existing infrastructure such as CA Pool resources and IAM principals (users, service accounts, groups). They focus on configuring IAM bindings rather than provisioning the underlying certificate infrastructure.

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

  • Full policy replacement (CaPoolIamPolicy)
  • Policy data retrieval (data source usage)
  • Custom role formatting and organization-level roles
  • Advanced condition expressions (resource attributes, request context)

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

Let's manage GCP Certificate Authority Pool IAM Bindings

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 CaPoolIamPolicy, CaPoolIamBinding, and CaPoolIamMember?
CaPoolIamPolicy is authoritative for the entire IAM policy and replaces any existing policy. CaPoolIamBinding is authoritative for a specific role, updating members for that role while preserving other roles. CaPoolIamMember is non-authoritative, adding a single member to a role while preserving other members.
Can I use CaPoolIamPolicy together with CaPoolIamBinding or CaPoolIamMember?
No, CaPoolIamPolicy cannot be used with CaPoolIamBinding or CaPoolIamMember because they will conflict over the IAM policy. Choose one approach: use CaPoolIamPolicy alone for full policy control, or use CaPoolIamBinding/CaPoolIamMember for granular role management.
Can I use CaPoolIamBinding and CaPoolIamMember together?
Yes, but only if they manage different roles. Using both resources for the same role will cause conflicts.
Configuration & Setup
What member identity formats are supported?
You can use: allUsers, allAuthenticatedUsers, user:{email}, serviceAccount:{email}, group:{email}, domain:{domain}, projectOwner:{projectid}, projectEditor:{projectid}, projectViewer:{projectid}, and federated identities like principal://iam.googleapis.com/locations/global/workforcePools/{pool}/subject/{user}.
What properties can't I change after creating a CaPoolIamBinding?
The caPool, location, project, role, and condition properties are immutable and cannot be changed after creation.
How is the location determined if I don't specify it?
If not specified, the location is parsed from the CA Pool identifier. If the identifier doesn’t include a location, it’s taken from the provider configuration.
IAM Conditions
How do I add IAM Conditions to a binding?
Set the condition property with title, description, and expression fields. For example, you can create time-based conditions using expressions like request.time < timestamp("2020-01-01T00:00:00Z").
What are the limitations of IAM Conditions?
IAM Conditions are supported but have known limitations. Review the GCP IAM Conditions limitations documentation if you encounter issues.
Advanced Configuration
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/customCertManager.

Using a different cloud?

Explore security guides for other cloud providers:

AWS Guides Azure Guides