Create GCP Regional Parameter Versions

The gcp:parametermanager/regionalParameterVersion:RegionalParameterVersion resource, part of the Pulumi GCP provider, stores the actual value of a regional parameter as a versioned resource. This guide focuses on three capabilities: plain text storage, JSON-formatted configuration, and file-based parameter loading.

Parameter versions belong to RegionalParameter resources and may reference external configuration files. The examples are intentionally small. Combine them with your own parameter definitions and configuration management workflows.

Store a plain text parameter value

Most deployments start by storing simple text values without format constraints.

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

const regional_parameter_basic = new gcp.parametermanager.RegionalParameter("regional-parameter-basic", {
    parameterId: "regional_parameter",
    location: "us-central1",
});
const regional_parameter_version_basic = new gcp.parametermanager.RegionalParameterVersion("regional-parameter-version-basic", {
    parameter: regional_parameter_basic.id,
    parameterVersionId: "regional_parameter_version",
    parameterData: "regional-parameter-version-data",
});

import pulumi
import pulumi_gcp as gcp

regional_parameter_basic = gcp.parametermanager.RegionalParameter("regional-parameter-basic",
    parameter_id="regional_parameter",
    location="us-central1")
regional_parameter_version_basic = gcp.parametermanager.RegionalParameterVersion("regional-parameter-version-basic",
    parameter=regional_parameter_basic.id,
    parameter_version_id="regional_parameter_version",
    parameter_data="regional-parameter-version-data")

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		regional_parameter_basic, err := parametermanager.NewRegionalParameter(ctx, "regional-parameter-basic", &parametermanager.RegionalParameterArgs{
			ParameterId: pulumi.String("regional_parameter"),
			Location:    pulumi.String("us-central1"),
		})
		if err != nil {
			return err
		}
		_, err = parametermanager.NewRegionalParameterVersion(ctx, "regional-parameter-version-basic", &parametermanager.RegionalParameterVersionArgs{
			Parameter:          regional_parameter_basic.ID(),
			ParameterVersionId: pulumi.String("regional_parameter_version"),
			ParameterData:      pulumi.String("regional-parameter-version-data"),
		})
		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 regional_parameter_basic = new Gcp.ParameterManager.RegionalParameter("regional-parameter-basic", new()
    {
        ParameterId = "regional_parameter",
        Location = "us-central1",
    });

    var regional_parameter_version_basic = new Gcp.ParameterManager.RegionalParameterVersion("regional-parameter-version-basic", new()
    {
        Parameter = regional_parameter_basic.Id,
        ParameterVersionId = "regional_parameter_version",
        ParameterData = "regional-parameter-version-data",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.parametermanager.RegionalParameter;
import com.pulumi.gcp.parametermanager.RegionalParameterArgs;
import com.pulumi.gcp.parametermanager.RegionalParameterVersion;
import com.pulumi.gcp.parametermanager.RegionalParameterVersionArgs;
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 regional_parameter_basic = new RegionalParameter("regional-parameter-basic", RegionalParameterArgs.builder()
            .parameterId("regional_parameter")
            .location("us-central1")
            .build());

        var regional_parameter_version_basic = new RegionalParameterVersion("regional-parameter-version-basic", RegionalParameterVersionArgs.builder()
            .parameter(regional_parameter_basic.id())
            .parameterVersionId("regional_parameter_version")
            .parameterData("regional-parameter-version-data")
            .build());

    }
}

resources:
  regional-parameter-basic:
    type: gcp:parametermanager:RegionalParameter
    properties:
      parameterId: regional_parameter
      location: us-central1
  regional-parameter-version-basic:
    type: gcp:parametermanager:RegionalParameterVersion
    properties:
      parameter: ${["regional-parameter-basic"].id}
      parameterVersionId: regional_parameter_version
      parameterData: regional-parameter-version-data

The parameter property references the parent RegionalParameter resource. The parameterVersionId provides a unique identifier within that parameter. The parameterData contains the actual configuration value, which is stored encrypted and marked as sensitive in Pulumi state.

Store structured JSON configuration data

Applications often need structured configuration that can be parsed and validated.

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

const regional_parameter_basic = new gcp.parametermanager.RegionalParameter("regional-parameter-basic", {
    parameterId: "regional_parameter",
    format: "JSON",
    location: "us-central1",
});
const regional_parameter_version_with_json_format = new gcp.parametermanager.RegionalParameterVersion("regional-parameter-version-with-json-format", {
    parameter: regional_parameter_basic.id,
    parameterVersionId: "regional_parameter_version",
    parameterData: JSON.stringify({
        key1: "val1",
        key2: "val2",
    }),
});

import pulumi
import json
import pulumi_gcp as gcp

regional_parameter_basic = gcp.parametermanager.RegionalParameter("regional-parameter-basic",
    parameter_id="regional_parameter",
    format="JSON",
    location="us-central1")
regional_parameter_version_with_json_format = gcp.parametermanager.RegionalParameterVersion("regional-parameter-version-with-json-format",
    parameter=regional_parameter_basic.id,
    parameter_version_id="regional_parameter_version",
    parameter_data=json.dumps({
        "key1": "val1",
        "key2": "val2",
    }))

package main

import (
	"encoding/json"

	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/parametermanager"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		regional_parameter_basic, err := parametermanager.NewRegionalParameter(ctx, "regional-parameter-basic", &parametermanager.RegionalParameterArgs{
			ParameterId: pulumi.String("regional_parameter"),
			Format:      pulumi.String("JSON"),
			Location:    pulumi.String("us-central1"),
		})
		if err != nil {
			return err
		}
		tmpJSON0, err := json.Marshal(map[string]interface{}{
			"key1": "val1",
			"key2": "val2",
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		_, err = parametermanager.NewRegionalParameterVersion(ctx, "regional-parameter-version-with-json-format", &parametermanager.RegionalParameterVersionArgs{
			Parameter:          regional_parameter_basic.ID(),
			ParameterVersionId: pulumi.String("regional_parameter_version"),
			ParameterData:      pulumi.String(json0),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using Pulumi;
using Gcp = Pulumi.Gcp;

return await Deployment.RunAsync(() => 
{
    var regional_parameter_basic = new Gcp.ParameterManager.RegionalParameter("regional-parameter-basic", new()
    {
        ParameterId = "regional_parameter",
        Format = "JSON",
        Location = "us-central1",
    });

    var regional_parameter_version_with_json_format = new Gcp.ParameterManager.RegionalParameterVersion("regional-parameter-version-with-json-format", new()
    {
        Parameter = regional_parameter_basic.Id,
        ParameterVersionId = "regional_parameter_version",
        ParameterData = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["key1"] = "val1",
            ["key2"] = "val2",
        }),
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.parametermanager.RegionalParameter;
import com.pulumi.gcp.parametermanager.RegionalParameterArgs;
import com.pulumi.gcp.parametermanager.RegionalParameterVersion;
import com.pulumi.gcp.parametermanager.RegionalParameterVersionArgs;
import static com.pulumi.codegen.internal.Serialization.*;
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 regional_parameter_basic = new RegionalParameter("regional-parameter-basic", RegionalParameterArgs.builder()
            .parameterId("regional_parameter")
            .format("JSON")
            .location("us-central1")
            .build());

        var regional_parameter_version_with_json_format = new RegionalParameterVersion("regional-parameter-version-with-json-format", RegionalParameterVersionArgs.builder()
            .parameter(regional_parameter_basic.id())
            .parameterVersionId("regional_parameter_version")
            .parameterData(serializeJson(
                jsonObject(
                    jsonProperty("key1", "val1"),
                    jsonProperty("key2", "val2")
                )))
            .build());

    }
}

resources:
  regional-parameter-basic:
    type: gcp:parametermanager:RegionalParameter
    properties:
      parameterId: regional_parameter
      format: JSON
      location: us-central1
  regional-parameter-version-with-json-format:
    type: gcp:parametermanager:RegionalParameterVersion
    properties:
      parameter: ${["regional-parameter-basic"].id}
      parameterVersionId: regional_parameter_version
      parameterData:
        fn::toJSON:
          key1: val1
          key2: val2

When the parent parameter has format set to JSON, you can store structured objects. The JSON.stringify call converts the JavaScript object into a JSON string that Parameter Manager validates against the declared format. This ensures configuration integrity at write time.

Load JSON configuration from a file

Teams managing large configurations often maintain them as separate files in version control.

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

const regional_parameter_basic = new gcp.parametermanager.RegionalParameter("regional-parameter-basic", {
    parameterId: "regional_parameter",
    format: "JSON",
    location: "us-central1",
});
const regional_parameter_version_with_json_format_with_file = new gcp.parametermanager.RegionalParameterVersion("regional-parameter-version-with-json-format-with-file", {
    parameter: regional_parameter_basic.id,
    parameterVersionId: "regional_parameter_version",
    parameterData: std.file({
        input: "regional-parameter-json-data.json",
    }).then(invoke => invoke.result),
});

import pulumi
import pulumi_gcp as gcp
import pulumi_std as std

regional_parameter_basic = gcp.parametermanager.RegionalParameter("regional-parameter-basic",
    parameter_id="regional_parameter",
    format="JSON",
    location="us-central1")
regional_parameter_version_with_json_format_with_file = gcp.parametermanager.RegionalParameterVersion("regional-parameter-version-with-json-format-with-file",
    parameter=regional_parameter_basic.id,
    parameter_version_id="regional_parameter_version",
    parameter_data=std.file(input="regional-parameter-json-data.json").result)

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/parametermanager"
	"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 {
		regional_parameter_basic, err := parametermanager.NewRegionalParameter(ctx, "regional-parameter-basic", &parametermanager.RegionalParameterArgs{
			ParameterId: pulumi.String("regional_parameter"),
			Format:      pulumi.String("JSON"),
			Location:    pulumi.String("us-central1"),
		})
		if err != nil {
			return err
		}
		invokeFile, err := std.File(ctx, &std.FileArgs{
			Input: "regional-parameter-json-data.json",
		}, nil)
		if err != nil {
			return err
		}
		_, err = parametermanager.NewRegionalParameterVersion(ctx, "regional-parameter-version-with-json-format-with-file", &parametermanager.RegionalParameterVersionArgs{
			Parameter:          regional_parameter_basic.ID(),
			ParameterVersionId: pulumi.String("regional_parameter_version"),
			ParameterData:      pulumi.String(invokeFile.Result),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
using Std = Pulumi.Std;

return await Deployment.RunAsync(() => 
{
    var regional_parameter_basic = new Gcp.ParameterManager.RegionalParameter("regional-parameter-basic", new()
    {
        ParameterId = "regional_parameter",
        Format = "JSON",
        Location = "us-central1",
    });

    var regional_parameter_version_with_json_format_with_file = new Gcp.ParameterManager.RegionalParameterVersion("regional-parameter-version-with-json-format-with-file", new()
    {
        Parameter = regional_parameter_basic.Id,
        ParameterVersionId = "regional_parameter_version",
        ParameterData = Std.File.Invoke(new()
        {
            Input = "regional-parameter-json-data.json",
        }).Apply(invoke => invoke.Result),
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.parametermanager.RegionalParameter;
import com.pulumi.gcp.parametermanager.RegionalParameterArgs;
import com.pulumi.gcp.parametermanager.RegionalParameterVersion;
import com.pulumi.gcp.parametermanager.RegionalParameterVersionArgs;
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 regional_parameter_basic = new RegionalParameter("regional-parameter-basic", RegionalParameterArgs.builder()
            .parameterId("regional_parameter")
            .format("JSON")
            .location("us-central1")
            .build());

        var regional_parameter_version_with_json_format_with_file = new RegionalParameterVersion("regional-parameter-version-with-json-format-with-file", RegionalParameterVersionArgs.builder()
            .parameter(regional_parameter_basic.id())
            .parameterVersionId("regional_parameter_version")
            .parameterData(StdFunctions.file(FileArgs.builder()
                .input("regional-parameter-json-data.json")
                .build()).result())
            .build());

    }
}

resources:
  regional-parameter-basic:
    type: gcp:parametermanager:RegionalParameter
    properties:
      parameterId: regional_parameter
      format: JSON
      location: us-central1
  regional-parameter-version-with-json-format-with-file:
    type: gcp:parametermanager:RegionalParameterVersion
    properties:
      parameter: ${["regional-parameter-basic"].id}
      parameterVersionId: regional_parameter_version
      parameterData:
        fn::invoke:
          function: std:file
          arguments:
            input: regional-parameter-json-data.json
          return: result

The std.file function reads configuration from an external file at deployment time. This separates configuration content from infrastructure code, making it easier to manage complex JSON objects or share configuration across multiple parameter versions. The parent parameter must still have format set to JSON for validation.

Beyond these examples

These snippets focus on specific parameter version features: plain text and structured data storage, and inline values and file-based loading. They’re intentionally minimal rather than full configuration management solutions.

The examples rely on pre-existing infrastructure such as RegionalParameter resources with appropriate format settings, and configuration files for file-based examples. They focus on storing parameter values rather than provisioning the parameter definitions themselves.

To keep things focused, common parameter version patterns are omitted, including:

Version disabling (disabled property)
KMS encryption configuration
YAML format handling
Version lifecycle management

These omissions are intentional: the goal is to illustrate how each parameter version feature is wired, not provide drop-in configuration modules. See the RegionalParameterVersion resource reference for all available configuration options.

Let's create GCP Regional Parameter Versions

Get started with Pulumi Cloud, then follow our quick setup guide to deploy this infrastructure.

Try Pulumi Cloud for FREE

Frequently Asked Questions

Immutability & Updates

What properties are immutable after creating a parameter version?

The parameter, parameterData, and parameterVersionId properties cannot be changed after creation. Only the disabled field can be updated.

How do I update the data in a parameter version?

You cannot modify parameterData after creation. Instead, create a new RegionalParameterVersion resource with a different parameterVersionId and the updated data.

What's the only property I can change after creating a version?

Only the disabled field can be updated after creation to enable or disable the parameter version.

Data Formats & File Loading

How do I store JSON or YAML data in a parameter version?

Set the format property (JSON or YAML) on the parent RegionalParameter resource, then pass your data as a string to parameterData. For JSON, use JSON.stringify() to convert objects to strings.

How do I load parameter data from a file?

Use the std.file() function with the input property pointing to your file path. The function returns the file contents as a string for parameterData.

Security & Visibility

Why doesn't my parameter data show up in the Pulumi plan output?

The parameterData property is marked as sensitive and will not be displayed in plan output for security reasons. The data is still stored and applied correctly.

How do I encrypt parameter data with a KMS key?

Configure the kmsKey property on the parent RegionalParameter resource. All versions of that parameter will automatically use the specified KMS key for encryption.

Where can I find the KMS key version used to encrypt my parameter?

The kmsKeyVersion output property contains the full resource name of the Cloud KMS CryptoKeyVersion used for encryption.

Using a different cloud?

Explore security guides for other cloud providers:

AWS Guides Azure Guides