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

TrustConfigArgs

data class TrustConfigArgs(val allowlistedCertificates: Output<List<TrustConfigAllowlistedCertificateArgs>>? = null, val description: Output<String>? = null, val labels: Output<Map<String, String>>? = null, val location: Output<String>? = null, val name: Output<String>? = null, val project: Output<String>? = null, val trustStores: Output<List<TrustConfigTrustStoreArgs>>? = null) : ConvertibleToJava<TrustConfigArgs>

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:

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",
    },
});
Content copied to clipboard
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",
    })
Content copied to clipboard
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" },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/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
	})
}
Content copied to clipboard
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 com.pulumi.std.StdFunctions;
import com.pulumi.std.inputs.FileArgs;
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());
    }
}
Content copied to clipboard
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
Content copied to clipboard

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",
    },
});
Content copied to clipboard
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",
    })
Content copied to clipboard
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" },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/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
	})
}
Content copied to clipboard
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 com.pulumi.std.StdFunctions;
import com.pulumi.std.inputs.FileArgs;
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());
    }
}
Content copied to clipboard
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
Content copied to clipboard

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}}
Content copied to clipboard
$ pulumi import gcp:certificatemanager/trustConfig:TrustConfig default {{project}}/{{location}}/{{name}}
Content copied to clipboard
$ pulumi import gcp:certificatemanager/trustConfig:TrustConfig default {{location}}/{{name}}
Content copied to clipboard

Constructors

Link copied to clipboard
constructor(allowlistedCertificates: Output<List<TrustConfigAllowlistedCertificateArgs>>? = null, description: Output<String>? = null, labels: Output<Map<String, String>>? = null, location: Output<String>? = null, name: Output<String>? = null, project: Output<String>? = null, trustStores: Output<List<TrustConfigTrustStoreArgs>>? = null)

Properties

Link copied to clipboard
val allowlistedCertificates: Output<List<TrustConfigAllowlistedCertificateArgs>>? = null

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.

Link copied to clipboard
val description: Output<String>? = null

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

Link copied to clipboard
val labels: Output<Map<String, String>>? = null

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.

Link copied to clipboard
val location: Output<String>? = null

The trust config location.

Link copied to clipboard
val name: Output<String>? = null

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

Link copied to clipboard
val project: Output<String>? = null

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

Link copied to clipboard
val trustStores: Output<List<TrustConfigTrustStoreArgs>>? = null

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.

Functions

Link copied to clipboard
open override fun toJava(): TrustConfigArgs