# BuildEnvironmentVariable

- Source: [`aws-codebuild/lib/project.ts`](https://github.com/aws/aws-cdk/blob/v2.277.0/packages/aws-cdk-lib/aws-codebuild/lib/project.ts#L2365)

## Example

TypeScript:

```ts
const sourceOutput = new codepipeline.Artifact();
const buildAction = new codepipeline_actions.CodeBuildAction({
  actionName: 'Build1',
  input: sourceOutput,
  project: new codebuild.PipelineProject(this, 'Project', {
    buildSpec: codebuild.BuildSpec.fromObject({
      version: '0.2',
      env: {
        'exported-variables': [
          'MY_VAR',
        ],
      },
      phases: {
        build: {
          commands: 'export MY_VAR="some value"',
        },
      },
    }),
  }),
  variablesNamespace: 'MyNamespace', // optional - by default, a name will be generated for you
});

// later:
declare const project: codebuild.PipelineProject;
new codepipeline_actions.CodeBuildAction({
  actionName: 'CodeBuild',
  project,
  input: sourceOutput,
  environmentVariables: {
    MyVar: {
      value: buildAction.variable('MY_VAR'),
    },
  },
});
```

Python:

```python
# later:
# project: codebuild.PipelineProject
source_output = codepipeline.Artifact()
build_action = codepipeline_actions.CodeBuildAction(
    action_name="Build1",
    input=source_output,
    project=codebuild.PipelineProject(self, "Project",
        build_spec=codebuild.BuildSpec.from_object({
            "version": "0.2",
            "env": {
                "exported-variables": ["MY_VAR"
                ]
            },
            "phases": {
                "build": {
                    "commands": "export MY_VAR=\"some value\""
                }
            }
        })
    ),
    variables_namespace="MyNamespace"
)
codepipeline_actions.CodeBuildAction(
    action_name="CodeBuild",
    project=project,
    input=source_output,
    environment_variables={
        "MyVar": codebuild.BuildEnvironmentVariable(
            value=build_action.variable("MY_VAR")
        )
    }
)
```

Java:

```java
// later:
PipelineProject project;
Artifact sourceOutput = new Artifact();
CodeBuildAction buildAction = CodeBuildAction.Builder.create()
        .actionName("Build1")
        .input(sourceOutput)
        .project(PipelineProject.Builder.create(this, "Project")
                .buildSpec(BuildSpec.fromObject(Map.of(
                        "version", "0.2",
                        "env", Map.of(
                                "exported-variables", List.of("MY_VAR")),
                        "phases", Map.of(
                                "build", Map.of(
                                        "commands", "export MY_VAR=\"some value\"")))))
                .build())
        .variablesNamespace("MyNamespace")
        .build();
CodeBuildAction.Builder.create()
        .actionName("CodeBuild")
        .project(project)
        .input(sourceOutput)
        .environmentVariables(Map.of(
                "MyVar", BuildEnvironmentVariable.builder()
                        .value(buildAction.variable("MY_VAR"))
                        .build()))
        .build();
```

C# / .NET:

```csharp
// Install: dotnet add package Amazon.CDK.Lib
// later:
PipelineProject project;
var sourceOutput = new Artifact();
var buildAction = new CodeBuildAction(new CodeBuildActionProps {
    ActionName = "Build1",
    Input = sourceOutput,
    Project = new PipelineProject(this, "Project", new PipelineProjectProps {
        BuildSpec = BuildSpec.FromObject(new Dictionary<string, object> {
            { "version", "0.2" },
            { "env", new Dictionary<string, string[]> {
                { "exported-variables", new [] { "MY_VAR" } }
            } },
            { "phases", new Dictionary<string, IDictionary<string, string>> {
                { "build", new Struct {
                    Commands = "export MY_VAR=\"some value\""
                } }
            } }
        })
    }),
    VariablesNamespace = "MyNamespace"
});
new CodeBuildAction(new CodeBuildActionProps {
    ActionName = "CodeBuild",
    Project = project,
    Input = sourceOutput,
    EnvironmentVariables = new Dictionary<string, BuildEnvironmentVariable> {
        { "MyVar", new BuildEnvironmentVariable {
            Value = buildAction.Variable("MY_VAR")
        } }
    }
});
```

Golang:

```go
// Install: go get github.com/aws/aws-cdk-go/awscdk/v2
// later:
var project PipelineProject
sourceOutput := codepipeline.NewArtifact()
buildAction := codepipeline_actions.NewCodeBuildAction(&CodeBuildActionProps{
	ActionName: jsii.String("Build1"),
	Input: sourceOutput,
	Project: codebuild.NewPipelineProject(this, jsii.String("Project"), &PipelineProjectProps{
		BuildSpec: codebuild.BuildSpec_FromObject(map[string]interface{}{
			"version": jsii.String("0.2"),
			"env": map[string][]*string{
				"exported-variables": []*string{
					jsii.String("MY_VAR"),
				},
			},
			"phases": map[string]map[string]*string{
				"build": map[string]*string{
					"commands": jsii.String("export MY_VAR=\"some value\""),
				},
			},
		}),
	}),
	VariablesNamespace: jsii.String("MyNamespace"),
})
codepipeline_actions.NewCodeBuildAction(&CodeBuildActionProps{
	ActionName: jsii.String("CodeBuild"),
	Project: Project,
	Input: sourceOutput,
	EnvironmentVariables: map[string]BuildEnvironmentVariable{
		"MyVar": &BuildEnvironmentVariable{
			"value": buildAction.variable(jsii.String("MY_VAR")),
		},
	},
})
```

## Properties

- `type`: [BuildEnvironmentVariableType](/cdk/api/v2/docs/aws-cdk-lib.aws_codebuild.BuildEnvironmentVariableType.html) = PlainText — The type of environment variable.

- `value`: any (required) — The value of the environment variable.

  For plain-text variables (the default), this is the literal value of variable.
  For SSM parameter variables, pass the name of the parameter here (`parameterName` property of `IParameter`).
  For SecretsManager variables secrets, pass either the secret name (`secretName` property of `ISecret`)
  or the secret ARN (`secretArn` property of `ISecret`) here,
  along with optional SecretsManager qualifiers separated by ':', like the JSON key, or the version or stage
  (see https://docs.aws.amazon.com/codebuild/latest/userguide/build-spec-ref.html#build-spec.env.secrets-manager for details).
