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: the configuration data that applications retrieve at runtime. This guide focuses on three capabilities: plain text and structured data storage, JSON and YAML format handling, and file-based configuration loading.

Parameter versions belong to RegionalParameter resources that define the parameter’s identity and format. The examples are intentionally small. Combine them with your own parameter definitions and application integration.

Store a plain text parameter value

Most deployments start by storing a simple text value that applications can retrieve without hardcoding configuration.

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. Once created, the data is immutable; updates require creating a new version.

Store structured JSON configuration data

Applications often need multi-field configuration objects rather than single strings.

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, Parameter Manager validates the structure at creation time. The JSON.stringify call converts your configuration object into the string format required by parameterData. Applications parse this JSON at runtime to extract individual fields.

Load JSON configuration from a file

Teams managing large configuration objects 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 the file contents at deployment time. This keeps your Pulumi code clean while preserving configuration history in version control. The file must exist when you run pulumi up, and the parent parameter must have format set to JSON.

Load YAML configuration from a file

YAML format provides a more readable alternative for complex configuration, especially with nested structures.

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: "YAML",
    location: "us-central1",
});
const regional_parameter_version_with_yaml_format_with_file = new gcp.parametermanager.RegionalParameterVersion("regional-parameter-version-with-yaml-format-with-file", {
    parameter: regional_parameter_basic.id,
    parameterVersionId: "regional_parameter_version",
    parameterData: std.file({
        input: "regional-parameter-yaml-data.yaml",
    }).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="YAML",
    location="us-central1")
regional_parameter_version_with_yaml_format_with_file = gcp.parametermanager.RegionalParameterVersion("regional-parameter-version-with-yaml-format-with-file",
    parameter=regional_parameter_basic.id,
    parameter_version_id="regional_parameter_version",
    parameter_data=std.file(input="regional-parameter-yaml-data.yaml").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("YAML"),
			Location:    pulumi.String("us-central1"),
		})
		if err != nil {
			return err
		}
		invokeFile, err := std.File(ctx, &std.FileArgs{
			Input: "regional-parameter-yaml-data.yaml",
		}, nil)
		if err != nil {
			return err
		}
		_, err = parametermanager.NewRegionalParameterVersion(ctx, "regional-parameter-version-with-yaml-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 = "YAML",
        Location = "us-central1",
    });

    var regional_parameter_version_with_yaml_format_with_file = new Gcp.ParameterManager.RegionalParameterVersion("regional-parameter-version-with-yaml-format-with-file", new()
    {
        Parameter = regional_parameter_basic.Id,
        ParameterVersionId = "regional_parameter_version",
        ParameterData = Std.File.Invoke(new()
        {
            Input = "regional-parameter-yaml-data.yaml",
        }).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("YAML")
            .location("us-central1")
            .build());

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

    }
}

resources:
  regional-parameter-basic:
    type: gcp:parametermanager:RegionalParameter
    properties:
      parameterId: regional_parameter
      format: YAML
      location: us-central1
  regional-parameter-version-with-yaml-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-yaml-data.yaml
          return: result

YAML’s syntax makes multi-line values and nested objects easier to read than JSON. The parent parameter’s format property must be set to YAML. Parameter Manager validates the YAML structure when you create the version.

Beyond these examples

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

The examples reference pre-existing infrastructure such as RegionalParameter resources (parent parameters) and configuration files for file-based examples. They focus on storing parameter data rather than provisioning the surrounding parameter infrastructure.

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

Version disabling (disabled property)
KMS encryption configuration
Version lifecycle management
Cross-region parameter replication

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

Data Management & Updates

Can I update the parameter data in an existing version?

No, the parameter, parameterData, and parameterVersionId properties are immutable. To update parameter data, create a new parameter version instead of modifying an existing one.

Why doesn't my parameter data appear in Pulumi output?

The parameterData property is sensitive and won’t be displayed in Pulumi plans or outputs for security reasons. This is expected behavior.

How do I disable a parameter version?

Set the disabled property to true. Note that this field is only applicable for updating existing versions, not during initial creation.

Data Formats & Loading

How do I store JSON data in a parameter version?

Set format: "JSON" on the parent RegionalParameter resource, then use JSON.stringify() to convert your object to a string for parameterData.

Can I load parameter data from a file?

Yes, use the std.file() function to read file content into parameterData. This works for JSON, YAML, or any text format.

Security & Encryption

How do I encrypt parameter data with KMS?

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

Using a different cloud?

Explore security guides for other cloud providers:

AWS Guides Azure Guides