Manage GCP Certificate Authority Pool IAM Access

The gcp:certificateauthority/caPoolIamMember:CaPoolIamMember resource, part of the Pulumi GCP provider, grants IAM permissions on Certificate Authority Service CA pools by adding individual members to roles without affecting other bindings. This guide focuses on three capabilities: single-member role grants, time-limited access with IAM Conditions, and authoritative role bindings.

IAM resources for CA pools reference existing pools and assume the GCP provider is configured with project and location. The examples are intentionally small. Combine them with your own CA pool infrastructure and identity management.

Grant a single user access to a CA pool

When you need to add one user or service account to a role without replacing existing members, CaPoolIamMember provides non-authoritative access control.

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

The member property specifies the identity to grant access, using formats like “user:email@example.com” or “serviceAccount:name@project.iam.gserviceaccount.com”. The role property defines the permission level. This resource adds the member without affecting other members already bound to the role.

Add time-limited access with IAM Conditions

Temporary access grants expire automatically when IAM Conditions evaluate to false, eliminating manual cleanup for contractors or time-bound projects.

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",
    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.certificateauthority.CaPoolIamMember("member",
    ca_pool=default["id"],
    role="roles/privateca.certificateManager",
    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/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"),
			Condition: &certificateauthority.CaPoolIamMemberConditionArgs{
				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.CertificateAuthority.CaPoolIamMember("member", new()
    {
        CaPool = @default.Id,
        Role = "roles/privateca.certificateManager",
        Member = "user:jane@example.com",
        Condition = new Gcp.CertificateAuthority.Inputs.CaPoolIamMemberConditionArgs
        {
            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.CaPoolIamMember;
import com.pulumi.gcp.certificateauthority.CaPoolIamMemberArgs;
import com.pulumi.gcp.certificateauthority.inputs.CaPoolIamMemberConditionArgs;
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")
            .condition(CaPoolIamMemberConditionArgs.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:certificateauthority:CaPoolIamMember
    properties:
      caPool: ${default.id}
      role: roles/privateca.certificateManager
      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 defines when the binding is active. The expression property uses CEL (Common Expression Language) to compare request.time against a timestamp. When the condition evaluates to false, GCP automatically denies access without requiring you to delete the binding.

Bind multiple members to a role authoritatively

When you need to define the complete list of members for a role, CaPoolIamBinding replaces any existing members with your specified list.

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 members property takes an array of identities. Unlike CaPoolIamMember, this resource is authoritative for the specified role: it replaces all existing members with your list. Use this when you want to define the complete membership for a role in one place.

Beyond these examples

These snippets focus on specific IAM binding features: single-member grants (CaPoolIamMember), multi-member role bindings (CaPoolIamBinding), and time-based access with IAM Conditions. They’re intentionally minimal rather than full access control policies.

The examples reference pre-existing infrastructure such as CA pools (referenced by caPool property) and GCP project and location configuration. They focus on configuring IAM bindings rather than provisioning the underlying CA infrastructure.

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

  • Full policy replacement (CaPoolIamPolicy)
  • Project and location specification (inherited from provider or parent resource)
  • Custom role definitions and formatting
  • Federated identity and workload identity pool configuration

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

Let's manage GCP Certificate Authority Pool 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 to manage CA Pool permissions?
You have three options: CaPoolIamPolicy sets the entire IAM policy (authoritative), CaPoolIamBinding manages all members for a specific role (authoritative per role), or CaPoolIamMember adds individual members without affecting others (non-authoritative).
Can I use CaPoolIamPolicy with CaPoolIamBinding or CaPoolIamMember?
No, CaPoolIamPolicy cannot be used with CaPoolIamBinding or CaPoolIamMember because they will conflict over the IAM policy. Use CaPoolIamPolicy alone or use CaPoolIamBinding/CaPoolIamMember together.
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.
IAM Configuration & Identity Formats
What identity formats can I use for the member property?
Supported formats include allUsers, allAuthenticatedUsers, user:{email}, serviceAccount:{email}, group:{email}, domain:{domain}, projectOwner:{projectid}, projectEditor:{projectid}, projectViewer:{projectid}, and federated identities like principal://iam.googleapis.com/....
How do I specify a custom role?
Custom roles must use the format [projects|organizations]/{parent-name}/roles/{role-name}. For example, projects/my-project/roles/customCertManager.
What properties can't be changed after creating a CaPoolIamMember?
All properties are immutable: caPool, location, member, project, role, and condition. You must recreate the resource to change any of these.
Conditions & Advanced Features
How do I add time-based or conditional access to a CA Pool?
Use the condition property with title, description, and expression. For example, set expression to request.time < timestamp("2020-01-01T00:00:00Z") for access that expires at a specific time.
What are the limitations of IAM Conditions?
IAM Conditions have known limitations that may affect functionality. Review the limitations before using conditions in production.
What role should I use for certificate management?
The examples use roles/privateca.certificateManager for managing certificates in the CA Pool.

Using a different cloud?

Explore security guides for other cloud providers:

AWS Guides Azure Guides