harness.platform.getInfraVariableSet

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

// Look up an account level Variable Set. Omit both org_id and project_id.
const accountLevel = harness.platform.getInfraVariableSet({
    identifier: "account_variable_set",
});
// Look up an org level Variable Set. Set org_id only.
const orgLevel = harness.platform.getInfraVariableSet({
    identifier: "org_variable_set",
    orgId: exampleHarnessPlatformOrganization.id,
});
// Look up a project level Variable Set. Set both org_id and project_id.
const projectLevel = harness.platform.getInfraVariableSet({
    identifier: "project_variable_set",
    orgId: exampleHarnessPlatformOrganization.id,
    projectId: exampleHarnessPlatformProject.id,
});
// Consuming a Variable Set from a Workspace.
//
// The exported `id` is the bare identifier, with no scope prefix. Harness resolves an
// unprefixed reference against the Workspace's own org and project, so a Variable Set
// that lives above the Workspace must be referenced with a scope prefix:
//
//   account level -> "account.${...id}"
//   org level     -> "org.${...id}"
//   project level -> "${...id}" (no prefix, must be the same project as the Workspace)
//
// Referencing an account or org level Variable Set without the prefix fails with
// "404 Not Found ... variable set not found", because the lookup is scoped to the project.
const example = new harness.platform.Workspace("example", {
    identifier: "example",
    name: "example",
    orgId: exampleHarnessPlatformOrganization.id,
    projectId: exampleHarnessPlatformProject.id,
    provisionerType: "terraform",
    provisionerVersion: "1.5.7",
    repository: "https://github.com/org/repo",
    repositoryBranch: "main",
    repositoryPath: "tf/aws/basic",
    repositoryConnector: exampleHarnessPlatformConnectorGithub.id,
    providerConnector: exampleHarnessPlatformConnectorAws.id,
    variableSets: [
        accountLevel.then(accountLevel => `account.${accountLevel.id}`),
        orgLevel.then(orgLevel => `org.${orgLevel.id}`),
        projectLevel.then(projectLevel => projectLevel.id),
    ],
});

import pulumi
import pulumi_harness as harness

# Look up an account level Variable Set. Omit both org_id and project_id.
account_level = harness.platform.get_infra_variable_set(identifier="account_variable_set")
# Look up an org level Variable Set. Set org_id only.
org_level = harness.platform.get_infra_variable_set(identifier="org_variable_set",
    org_id=example_harness_platform_organization["id"])
# Look up a project level Variable Set. Set both org_id and project_id.
project_level = harness.platform.get_infra_variable_set(identifier="project_variable_set",
    org_id=example_harness_platform_organization["id"],
    project_id=example_harness_platform_project["id"])
# Consuming a Variable Set from a Workspace.
#
# The exported `id` is the bare identifier, with no scope prefix. Harness resolves an
# unprefixed reference against the Workspace's own org and project, so a Variable Set
# that lives above the Workspace must be referenced with a scope prefix:
#
#   account level -> "account.${...id}"
#   org level     -> "org.${...id}"
#   project level -> "${...id}" (no prefix, must be the same project as the Workspace)
#
# Referencing an account or org level Variable Set without the prefix fails with
# "404 Not Found ... variable set not found", because the lookup is scoped to the project.
example = harness.platform.Workspace("example",
    identifier="example",
    name="example",
    org_id=example_harness_platform_organization["id"],
    project_id=example_harness_platform_project["id"],
    provisioner_type="terraform",
    provisioner_version="1.5.7",
    repository="https://github.com/org/repo",
    repository_branch="main",
    repository_path="tf/aws/basic",
    repository_connector=example_harness_platform_connector_github["id"],
    provider_connector=example_harness_platform_connector_aws["id"],
    variable_sets=[
        f"account.{account_level.id}",
        f"org.{org_level.id}",
        project_level.id,
    ])

package main

import (
	"github.com/pulumi/pulumi-harness/sdk/go/harness/platform"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Look up an account level Variable Set. Omit both org_id and project_id.
		accountLevel, err := platform.LookupInfraVariableSet(ctx, &platform.LookupInfraVariableSetArgs{
			Identifier: "account_variable_set",
		}, nil)
		if err != nil {
			return err
		}
		// Look up an org level Variable Set. Set org_id only.
		orgLevel, err := platform.LookupInfraVariableSet(ctx, &platform.LookupInfraVariableSetArgs{
			Identifier: "org_variable_set",
			OrgId:      pulumi.StringRef(exampleHarnessPlatformOrganization.Id),
		}, nil)
		if err != nil {
			return err
		}
		// Look up a project level Variable Set. Set both org_id and project_id.
		projectLevel, err := platform.LookupInfraVariableSet(ctx, &platform.LookupInfraVariableSetArgs{
			Identifier: "project_variable_set",
			OrgId:      pulumi.StringRef(exampleHarnessPlatformOrganization.Id),
			ProjectId:  pulumi.StringRef(exampleHarnessPlatformProject.Id),
		}, nil)
		if err != nil {
			return err
		}
		// Consuming a Variable Set from a Workspace.
		//
		// The exported `id` is the bare identifier, with no scope prefix. Harness resolves an
		// unprefixed reference against the Workspace's own org and project, so a Variable Set
		// that lives above the Workspace must be referenced with a scope prefix:
		//
		//	account level -> "account.${...id}"
		//	org level     -> "org.${...id}"
		//	project level -> "${...id}" (no prefix, must be the same project as the Workspace)
		//
		// Referencing an account or org level Variable Set without the prefix fails with
		// "404 Not Found ... variable set not found", because the lookup is scoped to the project.
		_, err = platform.NewWorkspace(ctx, "example", &platform.WorkspaceArgs{
			Identifier:          pulumi.String("example"),
			Name:                pulumi.String("example"),
			OrgId:               pulumi.Any(exampleHarnessPlatformOrganization.Id),
			ProjectId:           pulumi.Any(exampleHarnessPlatformProject.Id),
			ProvisionerType:     pulumi.String("terraform"),
			ProvisionerVersion:  pulumi.String("1.5.7"),
			Repository:          pulumi.String("https://github.com/org/repo"),
			RepositoryBranch:    pulumi.String("main"),
			RepositoryPath:      pulumi.String("tf/aws/basic"),
			RepositoryConnector: pulumi.Any(exampleHarnessPlatformConnectorGithub.Id),
			ProviderConnector:   pulumi.Any(exampleHarnessPlatformConnectorAws.Id),
			VariableSets: pulumi.StringArray{
				pulumi.Sprintf("account.%v", accountLevel.Id),
				pulumi.Sprintf("org.%v", orgLevel.Id),
				pulumi.String(projectLevel.Id),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Harness = Pulumi.Harness;

return await Deployment.RunAsync(() => 
{
    // Look up an account level Variable Set. Omit both org_id and project_id.
    var accountLevel = Harness.Platform.GetInfraVariableSet.Invoke(new()
    {
        Identifier = "account_variable_set",
    });

    // Look up an org level Variable Set. Set org_id only.
    var orgLevel = Harness.Platform.GetInfraVariableSet.Invoke(new()
    {
        Identifier = "org_variable_set",
        OrgId = exampleHarnessPlatformOrganization.Id,
    });

    // Look up a project level Variable Set. Set both org_id and project_id.
    var projectLevel = Harness.Platform.GetInfraVariableSet.Invoke(new()
    {
        Identifier = "project_variable_set",
        OrgId = exampleHarnessPlatformOrganization.Id,
        ProjectId = exampleHarnessPlatformProject.Id,
    });

    // Consuming a Variable Set from a Workspace.
    //
    // The exported `id` is the bare identifier, with no scope prefix. Harness resolves an
    // unprefixed reference against the Workspace's own org and project, so a Variable Set
    // that lives above the Workspace must be referenced with a scope prefix:
    //
    //   account level -> "account.${...id}"
    //   org level     -> "org.${...id}"
    //   project level -> "${...id}" (no prefix, must be the same project as the Workspace)
    //
    // Referencing an account or org level Variable Set without the prefix fails with
    // "404 Not Found ... variable set not found", because the lookup is scoped to the project.
    var example = new Harness.Platform.Workspace("example", new()
    {
        Identifier = "example",
        Name = "example",
        OrgId = exampleHarnessPlatformOrganization.Id,
        ProjectId = exampleHarnessPlatformProject.Id,
        ProvisionerType = "terraform",
        ProvisionerVersion = "1.5.7",
        Repository = "https://github.com/org/repo",
        RepositoryBranch = "main",
        RepositoryPath = "tf/aws/basic",
        RepositoryConnector = exampleHarnessPlatformConnectorGithub.Id,
        ProviderConnector = exampleHarnessPlatformConnectorAws.Id,
        VariableSets = new[]
        {
            $"account.{accountLevel.Apply(getInfraVariableSetResult => getInfraVariableSetResult.Id)}",
            $"org.{orgLevel.Apply(getInfraVariableSetResult => getInfraVariableSetResult.Id)}",
            projectLevel.Apply(getInfraVariableSetResult => getInfraVariableSetResult.Id),
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.harness.platform.PlatformFunctions;
import com.pulumi.harness.platform.inputs.GetInfraVariableSetArgs;
import com.pulumi.harness.platform.Workspace;
import com.pulumi.harness.platform.WorkspaceArgs;
import java.util.ArrayList;
import java.util.Arrays;
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) {
        // Look up an account level Variable Set. Omit both org_id and project_id.
        final var accountLevel = PlatformFunctions.getInfraVariableSet(GetInfraVariableSetArgs.builder()
            .identifier("account_variable_set")
            .build());

        // Look up an org level Variable Set. Set org_id only.
        final var orgLevel = PlatformFunctions.getInfraVariableSet(GetInfraVariableSetArgs.builder()
            .identifier("org_variable_set")
            .orgId(exampleHarnessPlatformOrganization.id())
            .build());

        // Look up a project level Variable Set. Set both org_id and project_id.
        final var projectLevel = PlatformFunctions.getInfraVariableSet(GetInfraVariableSetArgs.builder()
            .identifier("project_variable_set")
            .orgId(exampleHarnessPlatformOrganization.id())
            .projectId(exampleHarnessPlatformProject.id())
            .build());

        // Consuming a Variable Set from a Workspace.
        //
        // The exported `id` is the bare identifier, with no scope prefix. Harness resolves an
        // unprefixed reference against the Workspace's own org and project, so a Variable Set
        // that lives above the Workspace must be referenced with a scope prefix:
        //
        //   account level -> "account.${...id}"
        //   org level     -> "org.${...id}"
        //   project level -> "${...id}" (no prefix, must be the same project as the Workspace)
        //
        // Referencing an account or org level Variable Set without the prefix fails with
        // "404 Not Found ... variable set not found", because the lookup is scoped to the project.
        var example = new Workspace("example", WorkspaceArgs.builder()
            .identifier("example")
            .name("example")
            .orgId(exampleHarnessPlatformOrganization.id())
            .projectId(exampleHarnessPlatformProject.id())
            .provisionerType("terraform")
            .provisionerVersion("1.5.7")
            .repository("https://github.com/org/repo")
            .repositoryBranch("main")
            .repositoryPath("tf/aws/basic")
            .repositoryConnector(exampleHarnessPlatformConnectorGithub.id())
            .providerConnector(exampleHarnessPlatformConnectorAws.id())
            .variableSets(            
                String.format("account.%s", accountLevel.id()),
                String.format("org.%s", orgLevel.id()),
                projectLevel.id())
            .build());

    }
}

resources:
  # Consuming a Variable Set from a Workspace.
  #
  # The exported `id` is the bare identifier, with no scope prefix. Harness resolves an
  # unprefixed reference against the Workspace's own org and project, so a Variable Set
  # that lives above the Workspace must be referenced with a scope prefix:
  #
  #   account level -> "account.${...id}"
  #   org level     -> "org.${...id}"
  #   project level -> "${...id}" (no prefix, must be the same project as the Workspace)
  #
  # Referencing an account or org level Variable Set without the prefix fails with
  # "404 Not Found ... variable set not found", because the lookup is scoped to the project.
  example:
    type: harness:platform:Workspace
    properties:
      identifier: example
      name: example
      orgId: ${exampleHarnessPlatformOrganization.id}
      projectId: ${exampleHarnessPlatformProject.id}
      provisionerType: terraform
      provisionerVersion: 1.5.7
      repository: https://github.com/org/repo
      repositoryBranch: main
      repositoryPath: tf/aws/basic
      repositoryConnector: ${exampleHarnessPlatformConnectorGithub.id}
      providerConnector: ${exampleHarnessPlatformConnectorAws.id}
      variableSets:
        - account.${accountLevel.id}
        - org.${orgLevel.id}
        - ${projectLevel.id}
variables:
  # Look up an account level Variable Set. Omit both org_id and project_id.
  accountLevel:
    fn::invoke:
      function: harness:platform:getInfraVariableSet
      arguments:
        identifier: account_variable_set
  # Look up an org level Variable Set. Set org_id only.
  orgLevel:
    fn::invoke:
      function: harness:platform:getInfraVariableSet
      arguments:
        identifier: org_variable_set
        orgId: ${exampleHarnessPlatformOrganization.id}
  # Look up a project level Variable Set. Set both org_id and project_id.
  projectLevel:
    fn::invoke:
      function: harness:platform:getInfraVariableSet
      arguments:
        identifier: project_variable_set
        orgId: ${exampleHarnessPlatformOrganization.id}
        projectId: ${exampleHarnessPlatformProject.id}

pulumi {
  required_providers {
    harness = {
      source = "pulumi/harness"
    }
  }
}

data "harness_platform_getinfravariableset" "accountLevel" {
  identifier = "account_variable_set"
}
data "harness_platform_getinfravariableset" "orgLevel" {
  identifier = "org_variable_set"
  org_id     = exampleHarnessPlatformOrganization.id
}
data "harness_platform_getinfravariableset" "projectLevel" {
  identifier = "project_variable_set"
  org_id     = exampleHarnessPlatformOrganization.id
  project_id = exampleHarnessPlatformProject.id
}

# Consuming a Variable Set from a Workspace.
#
# The exported `id` is the bare identifier, with no scope prefix. Harness resolves an
# unprefixed reference against the Workspace's own org and project, so a Variable Set
# that lives above the Workspace must be referenced with a scope prefix:
#
#   account level -> "account.${...id}"
#   org level     -> "org.${...id}"
#   project level -> "${...id}" (no prefix, must be the same project as the Workspace)
#
# Referencing an account or org level Variable Set without the prefix fails with
# "404 Not Found ... variable set not found", because the lookup is scoped to the project.
resource "harness_platform_workspace" "example" {
  identifier           = "example"
  name                 = "example"
  org_id               = exampleHarnessPlatformOrganization.id
  project_id           = exampleHarnessPlatformProject.id
  provisioner_type     = "terraform"
  provisioner_version  = "1.5.7"
  repository           = "https://github.com/org/repo"
  repository_branch    = "main"
  repository_path      = "tf/aws/basic"
  repository_connector = exampleHarnessPlatformConnectorGithub.id
  provider_connector   = exampleHarnessPlatformConnectorAws.id
  variable_sets        = ["account.${data.harness_platform_getinfravariableset.accountLevel.id}", "org.${data.harness_platform_getinfravariableset.orgLevel.id}", data.harness_platform_getinfravariableset.projectLevel.id]
}
# Look up an account level Variable Set. Omit both org_id and project_id.
# Look up an org level Variable Set. Set org_id only.
# Look up a project level Variable Set. Set both org_id and project_id.

function getInfraVariableSet(args: GetInfraVariableSetArgs, opts?: InvokeOptions): Promise<GetInfraVariableSetResult>
function getInfraVariableSetOutput(args: GetInfraVariableSetOutputArgs, opts?: InvokeOutputOptions): Output<GetInfraVariableSetResult>

def get_infra_variable_set(identifier: Optional[str] = None,
                           name: Optional[str] = None,
                           org_id: Optional[str] = None,
                           project_id: Optional[str] = None,
                           opts: Optional[InvokeOptions] = None) -> GetInfraVariableSetResult
def get_infra_variable_set_output(identifier: pulumi.Input[Optional[str]] = None,
                           name: pulumi.Input[Optional[str]] = None,
                           org_id: pulumi.Input[Optional[str]] = None,
                           project_id: pulumi.Input[Optional[str]] = None,
                           opts: Optional[InvokeOutputOptions] = None) -> Output[GetInfraVariableSetResult]

func LookupInfraVariableSet(ctx *Context, args *LookupInfraVariableSetArgs, opts ...InvokeOption) (*LookupInfraVariableSetResult, error)
func LookupInfraVariableSetOutput(ctx *Context, args *LookupInfraVariableSetOutputArgs, opts ...InvokeOption) LookupInfraVariableSetResultOutput

public static class GetInfraVariableSet 
{
    public static Task<GetInfraVariableSetResult> InvokeAsync(GetInfraVariableSetArgs args, InvokeOptions? opts = null)
    public static Output<GetInfraVariableSetResult> Invoke(GetInfraVariableSetInvokeArgs args, InvokeOptions? opts = null)
    public static Output<GetInfraVariableSetResult> Invoke(GetInfraVariableSetInvokeArgs args, InvokeOutputOptions opts)
}

public static CompletableFuture<GetInfraVariableSetResult> getInfraVariableSet(GetInfraVariableSetArgs args, InvokeOptions options)
public static Output<GetInfraVariableSetResult> getInfraVariableSet(GetInfraVariableSetArgs args, InvokeOptions options)
public static Output<GetInfraVariableSetResult> getInfraVariableSet(GetInfraVariableSetArgs args, InvokeOutputOptions options)

fn::invoke:
  function: harness:platform/getInfraVariableSet:getInfraVariableSet
  arguments:
    # arguments dictionary

data "harness_platform_get_infra_variable_set" "name" {
    # arguments
}