pulumi-gcp-kotlin/com.pulumi.gcp.certificatemanager.kotlin/TrustConfig

TrustConfig

class TrustConfig : KotlinCustomResource

TrustConfig represents a resource that represents your Public Key Infrastructure (PKI) configuration in Certificate Manager for use in mutual TLS authentication scenarios. To get more information about TrustConfig, see:

API documentation
How-to Guides

Official Documentation

Example Usage

Certificate Manager Trust Config

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
import * as std from "@pulumi/std";
const _default = new gcp.certificatemanager.TrustConfig("default", {
    name: "trust-config",
    description: "sample description for the trust config",
    location: "us-central1",
    trustStores: [{
        trustAnchors: [{
            pemCertificate: std.file({
                input: "test-fixtures/cert.pem",
            }).then(invoke => invoke.result),
        }],
        intermediateCas: [{
            pemCertificate: std.file({
                input: "test-fixtures/cert.pem",
            }).then(invoke => invoke.result),
        }],
    }],
    labels: {
        foo: "bar",
    },
});

import pulumi
import pulumi_gcp as gcp
import pulumi_std as std
default = gcp.certificatemanager.TrustConfig("default",
    name="trust-config",
    description="sample description for the trust config",
    location="us-central1",
    trust_stores=[{
        "trust_anchors": [{
            "pem_certificate": std.file(input="test-fixtures/cert.pem").result,
        }],
        "intermediate_cas": [{
            "pem_certificate": std.file(input="test-fixtures/cert.pem").result,
        }],
    }],
    labels={
        "foo": "bar",
    })

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
using Std = Pulumi.Std;
return await Deployment.RunAsync(() =>
{
    var @default = new Gcp.CertificateManager.TrustConfig("default", new()
    {
        Name = "trust-config",
        Description = "sample description for the trust config",
        Location = "us-central1",
        TrustStores = new[]
        {
            new Gcp.CertificateManager.Inputs.TrustConfigTrustStoreArgs
            {
                TrustAnchors = new[]
                {
                    new Gcp.CertificateManager.Inputs.TrustConfigTrustStoreTrustAnchorArgs
                    {
                        PemCertificate = Std.File.Invoke(new()
                        {
                            Input = "test-fixtures/cert.pem",
                        }).Apply(invoke => invoke.Result),
                    },
                },
                IntermediateCas = new[]
                {
                    new Gcp.CertificateManager.Inputs.TrustConfigTrustStoreIntermediateCaArgs
                    {
                        PemCertificate = Std.File.Invoke(new()
                        {
                            Input = "test-fixtures/cert.pem",
                        }).Apply(invoke => invoke.Result),
                    },
                },
            },
        },
        Labels =
        {
            { "foo", "bar" },
        },
    });
});

package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/certificatemanager"
	"github.com/pulumi/pulumi-std/sdk/go/std"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		invokeFile, err := std.File(ctx, &std.FileArgs{
			Input: "test-fixtures/cert.pem",
		}, nil)
		if err != nil {
			return err
		}
		invokeFile1, err := std.File(ctx, &std.FileArgs{
			Input: "test-fixtures/cert.pem",
		}, nil)
		if err != nil {
			return err
		}
		_, err = certificatemanager.NewTrustConfig(ctx, "default", &certificatemanager.TrustConfigArgs{
			Name:        pulumi.String("trust-config"),
			Description: pulumi.String("sample description for the trust config"),
			Location:    pulumi.String("us-central1"),
			TrustStores: certificatemanager.TrustConfigTrustStoreArray{
				&certificatemanager.TrustConfigTrustStoreArgs{
					TrustAnchors: certificatemanager.TrustConfigTrustStoreTrustAnchorArray{
						&certificatemanager.TrustConfigTrustStoreTrustAnchorArgs{
							PemCertificate: pulumi.String(invokeFile.Result),
						},
					},
					IntermediateCas: certificatemanager.TrustConfigTrustStoreIntermediateCaArray{
						&certificatemanager.TrustConfigTrustStoreIntermediateCaArgs{
							PemCertificate: pulumi.String(invokeFile1.Result),
						},
					},
				},
			},
			Labels: pulumi.StringMap{
				"foo": pulumi.String("bar"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.certificatemanager.TrustConfig;
import com.pulumi.gcp.certificatemanager.TrustConfigArgs;
import com.pulumi.gcp.certificatemanager.inputs.TrustConfigTrustStoreArgs;
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 default_ = new TrustConfig("default", TrustConfigArgs.builder()
            .name("trust-config")
            .description("sample description for the trust config")
            .location("us-central1")
            .trustStores(TrustConfigTrustStoreArgs.builder()
                .trustAnchors(TrustConfigTrustStoreTrustAnchorArgs.builder()
                    .pemCertificate(StdFunctions.file(FileArgs.builder()
                        .input("test-fixtures/cert.pem")
                        .build()).result())
                    .build())
                .intermediateCas(TrustConfigTrustStoreIntermediateCaArgs.builder()
                    .pemCertificate(StdFunctions.file(FileArgs.builder()
                        .input("test-fixtures/cert.pem")
                        .build()).result())
                    .build())
                .build())
            .labels(Map.of("foo", "bar"))
            .build());
    }
}

resources:
  default:
    type: gcp:certificatemanager:TrustConfig
    properties:
      name: trust-config
      description: sample description for the trust config
      location: us-central1
      trustStores:
        - trustAnchors:
            - pemCertificate:
                fn::invoke:
                  Function: std:file
                  Arguments:
                    input: test-fixtures/cert.pem
                  Return: result
          intermediateCas:
            - pemCertificate:
                fn::invoke:
                  Function: std:file
                  Arguments:
                    input: test-fixtures/cert.pem
                  Return: result
      labels:
        foo: bar

Certificate Manager Trust Config Allowlisted Certificates

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
import * as std from "@pulumi/std";
const _default = new gcp.certificatemanager.TrustConfig("default", {
    name: "trust-config",
    description: "A sample trust config resource with allowlisted certificates",
    location: "global",
    allowlistedCertificates: [
        {
            pemCertificate: std.file({
                input: "test-fixtures/cert.pem",
            }).then(invoke => invoke.result),
        },
        {
            pemCertificate: std.file({
                input: "test-fixtures/cert2.pem",
            }).then(invoke => invoke.result),
        },
    ],
    labels: {
        foo: "bar",
    },
});

import pulumi
import pulumi_gcp as gcp
import pulumi_std as std
default = gcp.certificatemanager.TrustConfig("default",
    name="trust-config",
    description="A sample trust config resource with allowlisted certificates",
    location="global",
    allowlisted_certificates=[
        {
            "pem_certificate": std.file(input="test-fixtures/cert.pem").result,
        },
        {
            "pem_certificate": std.file(input="test-fixtures/cert2.pem").result,
        },
    ],
    labels={
        "foo": "bar",
    })

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
using Std = Pulumi.Std;
return await Deployment.RunAsync(() =>
{
    var @default = new Gcp.CertificateManager.TrustConfig("default", new()
    {
        Name = "trust-config",
        Description = "A sample trust config resource with allowlisted certificates",
        Location = "global",
        AllowlistedCertificates = new[]
        {
            new Gcp.CertificateManager.Inputs.TrustConfigAllowlistedCertificateArgs
            {
                PemCertificate = Std.File.Invoke(new()
                {
                    Input = "test-fixtures/cert.pem",
                }).Apply(invoke => invoke.Result),
            },
            new Gcp.CertificateManager.Inputs.TrustConfigAllowlistedCertificateArgs
            {
                PemCertificate = Std.File.Invoke(new()
                {
                    Input = "test-fixtures/cert2.pem",
                }).Apply(invoke => invoke.Result),
            },
        },
        Labels =
        {
            { "foo", "bar" },
        },
    });
});

package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/certificatemanager"
	"github.com/pulumi/pulumi-std/sdk/go/std"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		invokeFile, err := std.File(ctx, &std.FileArgs{
			Input: "test-fixtures/cert.pem",
		}, nil)
		if err != nil {
			return err
		}
		invokeFile1, err := std.File(ctx, &std.FileArgs{
			Input: "test-fixtures/cert2.pem",
		}, nil)
		if err != nil {
			return err
		}
		_, err = certificatemanager.NewTrustConfig(ctx, "default", &certificatemanager.TrustConfigArgs{
			Name:        pulumi.String("trust-config"),
			Description: pulumi.String("A sample trust config resource with allowlisted certificates"),
			Location:    pulumi.String("global"),
			AllowlistedCertificates: certificatemanager.TrustConfigAllowlistedCertificateArray{
				&certificatemanager.TrustConfigAllowlistedCertificateArgs{
					PemCertificate: pulumi.String(invokeFile.Result),
				},
				&certificatemanager.TrustConfigAllowlistedCertificateArgs{
					PemCertificate: pulumi.String(invokeFile1.Result),
				},
			},
			Labels: pulumi.StringMap{
				"foo": pulumi.String("bar"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.certificatemanager.TrustConfig;
import com.pulumi.gcp.certificatemanager.TrustConfigArgs;
import com.pulumi.gcp.certificatemanager.inputs.TrustConfigAllowlistedCertificateArgs;
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 default_ = new TrustConfig("default", TrustConfigArgs.builder()
            .name("trust-config")
            .description("A sample trust config resource with allowlisted certificates")
            .location("global")
            .allowlistedCertificates(
                TrustConfigAllowlistedCertificateArgs.builder()
                    .pemCertificate(StdFunctions.file(FileArgs.builder()
                        .input("test-fixtures/cert.pem")
                        .build()).result())
                    .build(),
                TrustConfigAllowlistedCertificateArgs.builder()
                    .pemCertificate(StdFunctions.file(FileArgs.builder()
                        .input("test-fixtures/cert2.pem")
                        .build()).result())
                    .build())
            .labels(Map.of("foo", "bar"))
            .build());
    }
}

resources:
  default:
    type: gcp:certificatemanager:TrustConfig
    properties:
      name: trust-config
      description: A sample trust config resource with allowlisted certificates
      location: global
      allowlistedCertificates:
        - pemCertificate:
            fn::invoke:
              Function: std:file
              Arguments:
                input: test-fixtures/cert.pem
              Return: result
        - pemCertificate:
            fn::invoke:
              Function: std:file
              Arguments:
                input: test-fixtures/cert2.pem
              Return: result
      labels:
        foo: bar

Import

TrustConfig can be imported using any of these accepted formats:

projects/{{project}}/locations/{{location}}/trustConfigs/{{name}}
{{project}}/{{location}}/{{name}}
{{location}}/{{name}} When using the pulumi import command, TrustConfig can be imported using one of the formats above. For example:

$ pulumi import gcp:certificatemanager/trustConfig:TrustConfig default projects/{{project}}/locations/{{location}}/trustConfigs/{{name}}

$ pulumi import gcp:certificatemanager/trustConfig:TrustConfig default {{project}}/{{location}}/{{name}}

$ pulumi import gcp:certificatemanager/trustConfig:TrustConfig default {{location}}/{{name}}

Properties

allowlistedCertificates

val allowlistedCertificates: Output<List<TrustConfigAllowlistedCertificate>>?

Allowlisted PEM-encoded certificates. A certificate matching an allowlisted certificate is always considered valid as long as the certificate is parseable, proof of private key possession is established, and constraints on the certificate's SAN field are met. Structure is documented below.

createTime

val createTime: Output<String>

The creation timestamp of a TrustConfig. A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up to nine fractional digits. Examples: "2014-10-02T15:01:23Z" and "2014-10-02T15:01:23.045123456Z".

description

val description: Output<String>?

One or more paragraphs of text description of a trust config.

effectiveLabels

val effectiveLabels: Output<Map<String, String>>

All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.

val id: Output<String>

labels

val labels: Output<Map<String, String>>?

Set of label tags associated with the trust config. Note: This field is non-authoritative, and will only manage the labels present in your configuration. Please refer to the field effective_labels for all of the labels present on the resource.

location

val location: Output<String>

The trust config location.

name

val name: Output<String>

A user-defined name of the trust config. Trust config names must be unique globally.

project

val project: Output<String>

The ID of the project in which the resource belongs. If it is not provided, the provider project is used.

pulumiChildResources

val pulumiChildResources: Set<KotlinResource>

pulumiLabels

val pulumiLabels: Output<Map<String, String>>

The combination of labels configured directly on the resource and default labels configured on the provider.

pulumiResourceName

val pulumiResourceName: String

pulumiResourceType

val pulumiResourceType: String

trustStores

val trustStores: Output<List<TrustConfigTrustStore>>?

Set of trust stores to perform validation against. This field is supported when TrustConfig is configured with Load Balancers, currently not supported for SPIFFE certificate validation. Structure is documented below.

updateTime

val updateTime: Output<String>

The last update timestamp of a TrustConfig. A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up to nine fractional digits. Examples: "2014-10-02T15:01:23Z" and "2014-10-02T15:01:23.045123456Z".

urn

val urn: Output<String>