pulumi-gcp-kotlin/com.pulumi.gcp.parametermanager.kotlin/Parameter

Parameter

class Parameter : KotlinCustomResource

A Parameter resource is a logical parameter. To get more information about Parameter, see:

Example Usage

Parameter Config Basic

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const parameter_basic = new gcp.parametermanager.Parameter("parameter-basic", {parameterId: "parameter"});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
parameter_basic = gcp.parametermanager.Parameter("parameter-basic", parameter_id="parameter")
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var parameter_basic = new Gcp.ParameterManager.Parameter("parameter-basic", new()
    {
        ParameterId = "parameter",
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/parametermanager"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := parametermanager.NewParameter(ctx, "parameter-basic", &parametermanager.ParameterArgs{
			ParameterId: pulumi.String("parameter"),
		})
		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.parametermanager.Parameter;
import com.pulumi.gcp.parametermanager.ParameterArgs;
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 parameter_basic = new Parameter("parameter-basic", ParameterArgs.builder()
            .parameterId("parameter")
            .build());
    }
}
Content copied to clipboard
resources:
  parameter-basic:
    type: gcp:parametermanager:Parameter
    properties:
      parameterId: parameter
Content copied to clipboard

Parameter With Format

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const parameter_with_format = new gcp.parametermanager.Parameter("parameter-with-format", {
    parameterId: "parameter",
    format: "JSON",
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
parameter_with_format = gcp.parametermanager.Parameter("parameter-with-format",
    parameter_id="parameter",
    format="JSON")
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var parameter_with_format = new Gcp.ParameterManager.Parameter("parameter-with-format", new()
    {
        ParameterId = "parameter",
        Format = "JSON",
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/parametermanager"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := parametermanager.NewParameter(ctx, "parameter-with-format", &parametermanager.ParameterArgs{
			ParameterId: pulumi.String("parameter"),
			Format:      pulumi.String("JSON"),
		})
		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.parametermanager.Parameter;
import com.pulumi.gcp.parametermanager.ParameterArgs;
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 parameter_with_format = new Parameter("parameter-with-format", ParameterArgs.builder()
            .parameterId("parameter")
            .format("JSON")
            .build());
    }
}
Content copied to clipboard
resources:
  parameter-with-format:
    type: gcp:parametermanager:Parameter
    properties:
      parameterId: parameter
      format: JSON
Content copied to clipboard

Parameter With Labels

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const parameter_with_labels = new gcp.parametermanager.Parameter("parameter-with-labels", {
    parameterId: "parameter",
    labels: {
        key1: "val1",
        key2: "val2",
        key3: "val3",
        key4: "val4",
        key5: "val5",
    },
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
parameter_with_labels = gcp.parametermanager.Parameter("parameter-with-labels",
    parameter_id="parameter",
    labels={
        "key1": "val1",
        "key2": "val2",
        "key3": "val3",
        "key4": "val4",
        "key5": "val5",
    })
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var parameter_with_labels = new Gcp.ParameterManager.Parameter("parameter-with-labels", new()
    {
        ParameterId = "parameter",
        Labels =
        {
            { "key1", "val1" },
            { "key2", "val2" },
            { "key3", "val3" },
            { "key4", "val4" },
            { "key5", "val5" },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/parametermanager"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := parametermanager.NewParameter(ctx, "parameter-with-labels", &parametermanager.ParameterArgs{
			ParameterId: pulumi.String("parameter"),
			Labels: pulumi.StringMap{
				"key1": pulumi.String("val1"),
				"key2": pulumi.String("val2"),
				"key3": pulumi.String("val3"),
				"key4": pulumi.String("val4"),
				"key5": pulumi.String("val5"),
			},
		})
		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.parametermanager.Parameter;
import com.pulumi.gcp.parametermanager.ParameterArgs;
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 parameter_with_labels = new Parameter("parameter-with-labels", ParameterArgs.builder()
            .parameterId("parameter")
            .labels(Map.ofEntries(
                Map.entry("key1", "val1"),
                Map.entry("key2", "val2"),
                Map.entry("key3", "val3"),
                Map.entry("key4", "val4"),
                Map.entry("key5", "val5")
            ))
            .build());
    }
}
Content copied to clipboard
resources:
  parameter-with-labels:
    type: gcp:parametermanager:Parameter
    properties:
      parameterId: parameter
      labels:
        key1: val1
        key2: val2
        key3: val3
        key4: val4
        key5: val5
Content copied to clipboard

Parameter With Kms Key

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const project = gcp.organizations.getProject({});
const parameter_with_kms_key = new gcp.parametermanager.Parameter("parameter-with-kms-key", {
    parameterId: "parameter",
    kmsKey: "kms-key",
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
project = gcp.organizations.get_project()
parameter_with_kms_key = gcp.parametermanager.Parameter("parameter-with-kms-key",
    parameter_id="parameter",
    kms_key="kms-key")
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var project = Gcp.Organizations.GetProject.Invoke();
    var parameter_with_kms_key = new Gcp.ParameterManager.Parameter("parameter-with-kms-key", new()
    {
        ParameterId = "parameter",
        KmsKey = "kms-key",
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/organizations"
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/parametermanager"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := organizations.LookupProject(ctx, &organizations.LookupProjectArgs{}, nil)
		if err != nil {
			return err
		}
		_, err = parametermanager.NewParameter(ctx, "parameter-with-kms-key", &parametermanager.ParameterArgs{
			ParameterId: pulumi.String("parameter"),
			KmsKey:      pulumi.String("kms-key"),
		})
		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.organizations.OrganizationsFunctions;
import com.pulumi.gcp.organizations.inputs.GetProjectArgs;
import com.pulumi.gcp.parametermanager.Parameter;
import com.pulumi.gcp.parametermanager.ParameterArgs;
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 project = OrganizationsFunctions.getProject(GetProjectArgs.builder()
            .build());
        var parameter_with_kms_key = new Parameter("parameter-with-kms-key", ParameterArgs.builder()
            .parameterId("parameter")
            .kmsKey("kms-key")
            .build());
    }
}
Content copied to clipboard
resources:
  parameter-with-kms-key:
    type: gcp:parametermanager:Parameter
    properties:
      parameterId: parameter
      kmsKey: kms-key
variables:
  project:
    fn::invoke:
      function: gcp:organizations:getProject
      arguments: {}
Content copied to clipboard

Import

Parameter can be imported using any of these accepted formats:

  • projects/{{project}}/locations/global/parameters/{{parameter_id}}

  • {{project}}/{{parameter_id}}

  • {{parameter_id}} When using the pulumi import command, Parameter can be imported using one of the formats above. For example:

$ pulumi import gcp:parametermanager/parameter:Parameter default projects/{{project}}/locations/global/parameters/{{parameter_id}}
Content copied to clipboard
$ pulumi import gcp:parametermanager/parameter:Parameter default {{project}}/{{parameter_id}}
Content copied to clipboard
$ pulumi import gcp:parametermanager/parameter:Parameter default {{parameter_id}}
Content copied to clipboard

Properties

Link copied to clipboard
val createTime: Output<String>

The time at which the Parameter was created.

Link copied to clipboard
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.

Link copied to clipboard
val format: Output<String>?

The format type of the parameter resource. Default value is UNFORMATTED. Possible values are: UNFORMATTED, YAML, JSON.

Link copied to clipboard
val id: Output<String>
Link copied to clipboard
val kmsKey: Output<String>?

The resource name of the Cloud KMS CryptoKey used to encrypt parameter version payload. Format projects/{{project}}/locations/global/keyRings/{{key_ring}}/cryptoKeys/{{crypto_key}}

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

The labels assigned to this Parameter. Label keys must be between 1 and 63 characters long, have a UTF-8 encoding of maximum 128 bytes, and must conform to the following PCRE regular expression: \p{Ll}\p{Lo}\p{N}_-{0,62} Label values must be between 0 and 63 characters long, have a UTF-8 encoding of maximum 128 bytes, and must conform to the following PCRE regular expression: \p{Ll}\p{Lo}\p{N}_-{0,63} No more than 64 labels can be assigned to a given resource. An object containing a list of "key": value pairs. Example: { "name": "wrench", "mass": "1.3kg", "count": "3" }. 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 name: Output<String>

The resource name of the Parameter. Format: projects/{{project}}/locations/global/parameters/{{parameter_id}}

Link copied to clipboard
val parameterId: Output<String>

This must be unique within the project.

Link copied to clipboard
val policyMembers: Output<List<ParameterPolicyMember>>

Policy member strings of a Google Cloud resource. Structure is documented below.

Link copied to clipboard
val project: Output<String>

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 pulumiChildResources: Set<KotlinResource>
Link copied to clipboard
val pulumiLabels: Output<Map<String, String>>

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

Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
val updateTime: Output<String>

The time at which the Parameter was updated.

Link copied to clipboard
val urn: Output<String>