vercel.ProjectEnvironmentVariable

Provides a Project Environment Variable resource.

A Project Environment Variable resource defines an Environment Variable on a Vercel Project.

For more detailed information, please see the Vercel documentation.

Terraform currently provides this Project Environment Variable resource (a single Environment Variable), a Project Environment Variables resource (multiple Environment Variables), and a Project resource with Environment Variables defined in-line via the environment field. At this time you cannot use a Vercel Project resource with in-line environment in conjunction with any vercel.ProjectEnvironmentVariables or vercel.ProjectEnvironmentVariable resources. Doing so will cause a conflict of settings and will overwrite Environment Variables.

Note: Starting in provider version 4.8.0, environment variables require an explicit sensitive value. Secrets (sensitive = true) are supported in all target environments, including Development. Team environment variable policies are enforced by the Vercel API at apply time.

Note: Write-Only argument value_wo is available to use in place of value. Write-Only arguments are supported in HashiCorp Terraform 1.11.0 and later. Learn more.

Create ProjectEnvironmentVariable Resource

Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

Constructor syntax

new ProjectEnvironmentVariable(name: string, args: ProjectEnvironmentVariableArgs, opts?: CustomResourceOptions);

@overload
def ProjectEnvironmentVariable(resource_name: str,
                               args: ProjectEnvironmentVariableArgs,
                               opts: Optional[ResourceOptions] = None)

@overload
def ProjectEnvironmentVariable(resource_name: str,
                               opts: Optional[ResourceOptions] = None,
                               key: Optional[str] = None,
                               project_id: Optional[str] = None,
                               sensitive: Optional[bool] = None,
                               comment: Optional[str] = None,
                               custom_environment_ids: Optional[Sequence[str]] = None,
                               git_branch: Optional[str] = None,
                               targets: Optional[Sequence[str]] = None,
                               team_id: Optional[str] = None,
                               value: Optional[str] = None,
                               value_wo: Optional[str] = None,
                               value_wo_version: Optional[int] = None,
                               visibility: Optional[str] = None)

func NewProjectEnvironmentVariable(ctx *Context, name string, args ProjectEnvironmentVariableArgs, opts ...ResourceOption) (*ProjectEnvironmentVariable, error)

public ProjectEnvironmentVariable(string name, ProjectEnvironmentVariableArgs args, CustomResourceOptions? opts = null)

public ProjectEnvironmentVariable(String name, ProjectEnvironmentVariableArgs args)
public ProjectEnvironmentVariable(String name, ProjectEnvironmentVariableArgs args, CustomResourceOptions options)

type: vercel:ProjectEnvironmentVariable
properties: # The arguments to resource properties.
options: # Bag of options to control resource's behavior.

resource "vercel_project_environment_variable" "name" {
    # resource properties
}

Parameters

Constructor example

The following reference example uses placeholder values for all input properties.

var projectEnvironmentVariableResource = new Vercel.ProjectEnvironmentVariable("projectEnvironmentVariableResource", new()
{
    Key = "string",
    ProjectId = "string",
    Sensitive = false,
    Comment = "string",
    CustomEnvironmentIds = new[]
    {
        "string",
    },
    GitBranch = "string",
    Targets = new[]
    {
        "string",
    },
    TeamId = "string",
    Value = "string",
    ValueWo = "string",
    ValueWoVersion = 0,
    Visibility = "string",
});

example, err := vercel.NewProjectEnvironmentVariable(ctx, "projectEnvironmentVariableResource", &vercel.ProjectEnvironmentVariableArgs{
	Key:       pulumi.String("string"),
	ProjectId: pulumi.String("string"),
	Sensitive: pulumi.Bool(false),
	Comment:   pulumi.String("string"),
	CustomEnvironmentIds: pulumi.StringArray{
		pulumi.String("string"),
	},
	GitBranch: pulumi.String("string"),
	Targets: pulumi.StringArray{
		pulumi.String("string"),
	},
	TeamId:         pulumi.String("string"),
	Value:          pulumi.String("string"),
	ValueWo:        pulumi.String("string"),
	ValueWoVersion: pulumi.Int(0),
	Visibility:     pulumi.String("string"),
})

resource "vercel_project_environment_variable" "projectEnvironmentVariableResource" {
  lifecycle {
    create_before_destroy = true
  }
  key                    = "string"
  project_id             = "string"
  sensitive              = false
  comment                = "string"
  custom_environment_ids = ["string"]
  git_branch             = "string"
  targets                = ["string"]
  team_id                = "string"
  value                  = "string"
  value_wo               = "string"
  value_wo_version       = 0
  visibility             = "string"
}

var projectEnvironmentVariableResource = new ProjectEnvironmentVariable("projectEnvironmentVariableResource", ProjectEnvironmentVariableArgs.builder()
    .key("string")
    .projectId("string")
    .sensitive(false)
    .comment("string")
    .customEnvironmentIds("string")
    .gitBranch("string")
    .targets("string")
    .teamId("string")
    .value("string")
    .valueWo("string")
    .valueWoVersion(0)
    .visibility("string")
    .build());

project_environment_variable_resource = vercel.ProjectEnvironmentVariable("projectEnvironmentVariableResource",
    key="string",
    project_id="string",
    sensitive=False,
    comment="string",
    custom_environment_ids=["string"],
    git_branch="string",
    targets=["string"],
    team_id="string",
    value="string",
    value_wo="string",
    value_wo_version=0,
    visibility="string")

const projectEnvironmentVariableResource = new vercel.ProjectEnvironmentVariable("projectEnvironmentVariableResource", {
    key: "string",
    projectId: "string",
    sensitive: false,
    comment: "string",
    customEnvironmentIds: ["string"],
    gitBranch: "string",
    targets: ["string"],
    teamId: "string",
    value: "string",
    valueWo: "string",
    valueWoVersion: 0,
    visibility: "string",
});

type: vercel:ProjectEnvironmentVariable
properties:
    comment: string
    customEnvironmentIds:
        - string
    gitBranch: string
    key: string
    projectId: string
    sensitive: false
    targets:
        - string
    teamId: string
    value: string
    valueWo: string
    valueWoVersion: 0
    visibility: string

ProjectEnvironmentVariable Resource Properties

To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

Inputs

The ProjectEnvironmentVariable resource accepts the following input properties:

Outputs

All input properties are implicitly available as output properties. Additionally, the ProjectEnvironmentVariable resource produces the following output properties:

Look up Existing ProjectEnvironmentVariable Resource

Get an existing ProjectEnvironmentVariable resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

public static get(name: string, id: Input<ID>, state?: ProjectEnvironmentVariableState, opts?: CustomResourceOptions): ProjectEnvironmentVariable

@staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        comment: Optional[str] = None,
        custom_environment_ids: Optional[Sequence[str]] = None,
        git_branch: Optional[str] = None,
        key: Optional[str] = None,
        project_id: Optional[str] = None,
        sensitive: Optional[bool] = None,
        targets: Optional[Sequence[str]] = None,
        team_id: Optional[str] = None,
        value: Optional[str] = None,
        value_wo: Optional[str] = None,
        value_wo_version: Optional[int] = None,
        visibility: Optional[str] = None) -> ProjectEnvironmentVariable

func GetProjectEnvironmentVariable(ctx *Context, name string, id IDInput, state *ProjectEnvironmentVariableState, opts ...ResourceOption) (*ProjectEnvironmentVariable, error)

public static ProjectEnvironmentVariable Get(string name, Input<string> id, ProjectEnvironmentVariableState? state, CustomResourceOptions? opts = null)

public static ProjectEnvironmentVariable get(String name, Output<String> id, ProjectEnvironmentVariableState state, CustomResourceOptions options)

resources:  _:    type: vercel:ProjectEnvironmentVariable    get:      id: ${id}

import {
  to = vercel_project_environment_variable.example
  id = "${id}"
}

Import

The pulumi import command can be used, for example:

If importing into a personal account, or with a team configured on the provider, simply use the project_id and environment variable id.

• project_id can be found in the project settings tab in the Vercel UI.
• environment variable id can be taken from the network tab inside developer tools, while you are on the project page, or can be queried from Vercel API directly (https://vercel.com/docs/rest-api/endpoints/projects#retrieve-the-environment-variables-of-a-project-by-id-or-name)

Note also, that the value field for sensitive environment variables will be imported as null.

$ pulumi import vercel:index/projectEnvironmentVariable:ProjectEnvironmentVariable example prj_xxxxxxxxxxxxxxxxxxxxxxxxxxxx/FdT2e1E5Of6Cihmt

Alternatively, you can import via the team_id, project_id and environment variable id.

• team_id can be found in the team settings tab in the Vercel UI.
• project_id can be found in the project settings tab in the Vercel UI.
• environment variable id can be taken from the network tab inside developer tools, while you are on the project page, or can be queried from Vercel API directly (https://vercel.com/docs/rest-api/endpoints/projects#retrieve-the-environment-variables-of-a-project-by-id-or-name)

Note also, that the value field for sensitive environment variables will be imported as null.

$ pulumi import vercel:index/projectEnvironmentVariable:ProjectEnvironmentVariable example team_xxxxxxxxxxxxxxxxxxxxxxxx/prj_xxxxxxxxxxxxxxxxxxxxxxxxxxxx/FdT2e1E5Of6Cihmt

When using value_wo, prefix either import ID format with write-only: to keep the value out of Terraform state. Set value_wo_version to control subsequent updates.

$ pulumi import vercel:index/projectEnvironmentVariable:ProjectEnvironmentVariable example 'write-only:team_xxxxxxxxxxxxxxxxxxxxxxxx/prj_xxxxxxxxxxxxxxxxxxxxxxxxxxxx/FdT2e1E5Of6Cihmt'

To learn more about importing existing cloud resources, see Importing resources.

Package Details

Repository

vercel pulumiverse/pulumi-vercel

License

Apache-2.0

Notes

This Pulumi package is based on the vercel Terraform Provider.