zpa.getTagKey

import * as pulumi from "@pulumi/pulumi";
import * as zpa from "@bdzscaler/pulumi-zpa";

const _this = zpa.getTagNamespace({
    name: "Example Namespace",
});
const thisGetTagKey = _this.then(_this => zpa.getTagKey({
    name: "Environment",
    namespaceId: _this.id,
}));
export const zpaTagKey = thisGetTagKey;

import pulumi
import pulumi_zpa as zpa

this = zpa.get_tag_namespace(name="Example Namespace")
this_get_tag_key = zpa.get_tag_key(name="Environment",
    namespace_id=this.id)
pulumi.export("zpaTagKey", this_get_tag_key)

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/zscaler/pulumi-zpa/sdk/go/zpa"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		this, err := zpa.GetTagNamespace(ctx, &zpa.LookupTagNamespaceArgs{
			Name: pulumi.StringRef("Example Namespace"),
		}, nil)
		if err != nil {
			return err
		}
		thisGetTagKey, err := zpa.GetTagKey(ctx, &zpa.LookupTagKeyArgs{
			Name:        pulumi.StringRef("Environment"),
			NamespaceId: this.Id,
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("zpaTagKey", thisGetTagKey)
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Zpa = zscaler.PulumiPackage.Zpa;

return await Deployment.RunAsync(() => 
{
    var @this = Zpa.GetTagNamespace.Invoke(new()
    {
        Name = "Example Namespace",
    });

    var thisGetTagKey = Zpa.GetTagKey.Invoke(new()
    {
        Name = "Environment",
        NamespaceId = @this.Apply(getTagNamespaceResult => getTagNamespaceResult.Id),
    });

    return new Dictionary<string, object?>
    {
        ["zpaTagKey"] = thisGetTagKey,
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.zpa.ZpaFunctions;
import com.pulumi.zpa.inputs.GetTagNamespaceArgs;
import com.pulumi.zpa.inputs.GetTagKeyArgs;
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 this = ZpaFunctions.getTagNamespace(GetTagNamespaceArgs.builder()
            .name("Example Namespace")
            .build());

        final var thisGetTagKey = ZpaFunctions.getTagKey(GetTagKeyArgs.builder()
            .name("Environment")
            .namespaceId(this_.id())
            .build());

        ctx.export("zpaTagKey", thisGetTagKey);
    }
}

variables:
  this:
    fn::invoke:
      function: zpa:getTagNamespace
      arguments:
        name: Example Namespace
  thisGetTagKey:
    fn::invoke:
      function: zpa:getTagKey
      arguments:
        name: Environment
        namespaceId: ${this.id}
outputs:
  zpaTagKey: ${thisGetTagKey}

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

data "zpa_gettagnamespace" "this" {
  name = "Example Namespace"
}
data "zpa_gettagkey" "thisGetTagKey" {
  name         = "Environment"
  namespace_id = data.zpa_gettagnamespace.this.id
}

output "zpaTagKey" {
  value = data.zpa_gettagkey.thisGetTagKey
}

function getTagKey(args: GetTagKeyArgs, opts?: InvokeOptions): Promise<GetTagKeyResult>
function getTagKeyOutput(args: GetTagKeyOutputArgs, opts?: InvokeOptions): Output<GetTagKeyResult>

def get_tag_key(id: Optional[str] = None,
                microtenant_id: Optional[str] = None,
                name: Optional[str] = None,
                namespace_id: Optional[str] = None,
                opts: Optional[InvokeOptions] = None) -> GetTagKeyResult
def get_tag_key_output(id: pulumi.Input[Optional[str]] = None,
                microtenant_id: pulumi.Input[Optional[str]] = None,
                name: pulumi.Input[Optional[str]] = None,
                namespace_id: pulumi.Input[Optional[str]] = None,
                opts: Optional[InvokeOptions] = None) -> Output[GetTagKeyResult]

func LookupTagKey(ctx *Context, args *LookupTagKeyArgs, opts ...InvokeOption) (*LookupTagKeyResult, error)
func LookupTagKeyOutput(ctx *Context, args *LookupTagKeyOutputArgs, opts ...InvokeOption) LookupTagKeyResultOutput

public static class GetTagKey 
{
    public static Task<GetTagKeyResult> InvokeAsync(GetTagKeyArgs args, InvokeOptions? opts = null)
    public static Output<GetTagKeyResult> Invoke(GetTagKeyInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetTagKeyResult> getTagKey(GetTagKeyArgs args, InvokeOptions options)
public static Output<GetTagKeyResult> getTagKey(GetTagKeyArgs args, InvokeOptions options)

fn::invoke:
  function: zpa:index/getTagKey:getTagKey
  arguments:
    # arguments dictionary

data "zpa_get_tag_key" "name" {
    # arguments
}