gcp.datacatalog.getTaxonomy

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

const example = gcp.datacatalog.getTaxonomy({
    displayName: "my_taxonomy",
    region: "us-central1",
});
const examplePolicyTag = new gcp.datacatalog.PolicyTag("example", {
    taxonomy: example.then(example => example.id),
    displayName: "example_policy_tag",
    description: "A policy tag",
});

import pulumi
import pulumi_gcp as gcp

example = gcp.datacatalog.get_taxonomy(display_name="my_taxonomy",
    region="us-central1")
example_policy_tag = gcp.datacatalog.PolicyTag("example",
    taxonomy=example.id,
    display_name="example_policy_tag",
    description="A policy tag")

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := datacatalog.LookupTaxonomy(ctx, &datacatalog.LookupTaxonomyArgs{
			DisplayName: "my_taxonomy",
			Region:      "us-central1",
		}, nil)
		if err != nil {
			return err
		}
		_, err = datacatalog.NewPolicyTag(ctx, "example", &datacatalog.PolicyTagArgs{
			Taxonomy:    pulumi.String(example.Id),
			DisplayName: pulumi.String("example_policy_tag"),
			Description: pulumi.String("A policy tag"),
		})
		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 example = Gcp.DataCatalog.GetTaxonomy.Invoke(new()
    {
        DisplayName = "my_taxonomy",
        Region = "us-central1",
    });

    var examplePolicyTag = new Gcp.DataCatalog.PolicyTag("example", new()
    {
        Taxonomy = example.Apply(getTaxonomyResult => getTaxonomyResult.Id),
        DisplayName = "example_policy_tag",
        Description = "A policy tag",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.datacatalog.DatacatalogFunctions;
import com.pulumi.gcp.datacatalog.inputs.GetTaxonomyArgs;
import com.pulumi.gcp.datacatalog.PolicyTag;
import com.pulumi.gcp.datacatalog.PolicyTagArgs;
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) {
        final var example = DatacatalogFunctions.getTaxonomy(GetTaxonomyArgs.builder()
            .displayName("my_taxonomy")
            .region("us-central1")
            .build());

        var examplePolicyTag = new PolicyTag("examplePolicyTag", PolicyTagArgs.builder()
            .taxonomy(example.id())
            .displayName("example_policy_tag")
            .description("A policy tag")
            .build());

    }
}

resources:
  examplePolicyTag:
    type: gcp:datacatalog:PolicyTag
    name: example
    properties:
      taxonomy: ${example.id}
      displayName: example_policy_tag
      description: A policy tag
variables:
  example:
    fn::invoke:
      function: gcp:datacatalog:getTaxonomy
      arguments:
        displayName: my_taxonomy
        region: us-central1

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

data "gcp_datacatalog_gettaxonomy" "example" {
  display_name = "my_taxonomy"
  region       = "us-central1"
}

resource "gcp_datacatalog_policytag" "example" {
  taxonomy     = data.gcp_datacatalog_gettaxonomy.example.id
  display_name = "example_policy_tag"
  description  = "A policy tag"
}

function getTaxonomy(args: GetTaxonomyArgs, opts?: InvokeOptions): Promise<GetTaxonomyResult>
function getTaxonomyOutput(args: GetTaxonomyOutputArgs, opts?: InvokeOptions): Output<GetTaxonomyResult>

def get_taxonomy(display_name: Optional[str] = None,
                 project: Optional[str] = None,
                 region: Optional[str] = None,
                 opts: Optional[InvokeOptions] = None) -> GetTaxonomyResult
def get_taxonomy_output(display_name: pulumi.Input[Optional[str]] = None,
                 project: pulumi.Input[Optional[str]] = None,
                 region: pulumi.Input[Optional[str]] = None,
                 opts: Optional[InvokeOptions] = None) -> Output[GetTaxonomyResult]

func LookupTaxonomy(ctx *Context, args *LookupTaxonomyArgs, opts ...InvokeOption) (*LookupTaxonomyResult, error)
func LookupTaxonomyOutput(ctx *Context, args *LookupTaxonomyOutputArgs, opts ...InvokeOption) LookupTaxonomyResultOutput

public static class GetTaxonomy 
{
    public static Task<GetTaxonomyResult> InvokeAsync(GetTaxonomyArgs args, InvokeOptions? opts = null)
    public static Output<GetTaxonomyResult> Invoke(GetTaxonomyInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetTaxonomyResult> getTaxonomy(GetTaxonomyArgs args, InvokeOptions options)
public static Output<GetTaxonomyResult> getTaxonomy(GetTaxonomyArgs args, InvokeOptions options)

fn::invoke:
  function: gcp:datacatalog/getTaxonomy:getTaxonomy
  arguments:
    # arguments dictionary

data "gcp_datacatalog_get_taxonomy" "name" {
    # arguments
}