nsxt.getPolicyEdgeNode

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

const ec = nsxt.getPolicyEdgeCluster({
    displayName: "ec",
});
const node1 = ec.then(ec => nsxt.getPolicyEdgeNode({
    edgeClusterPath: ec.path,
    memberIndex: 0,
}));

import pulumi
import pulumi_nsxt as nsxt

ec = nsxt.get_policy_edge_cluster(display_name="ec")
node1 = nsxt.get_policy_edge_node(edge_cluster_path=ec.path,
    member_index=0)

package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/nsxt/v3/nsxt"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		ec, err := nsxt.LookupPolicyEdgeCluster(ctx, &nsxt.LookupPolicyEdgeClusterArgs{
			DisplayName: pulumi.StringRef("ec"),
		}, nil)
		if err != nil {
			return err
		}
		_, err = nsxt.GetPolicyEdgeNode(ctx, &nsxt.GetPolicyEdgeNodeArgs{
			EdgeClusterPath: ec.Path,
			MemberIndex:     pulumi.Float64Ref(0),
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var ec = Nsxt.GetPolicyEdgeCluster.Invoke(new()
    {
        DisplayName = "ec",
    });

    var node1 = Nsxt.GetPolicyEdgeNode.Invoke(new()
    {
        EdgeClusterPath = ec.Apply(getPolicyEdgeClusterResult => getPolicyEdgeClusterResult.Path),
        MemberIndex = 0,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.nsxt.NsxtFunctions;
import com.pulumi.nsxt.inputs.GetPolicyEdgeClusterArgs;
import com.pulumi.nsxt.inputs.GetPolicyEdgeNodeArgs;
import java.util.List;
import java.util.ArrayList;
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 ec = NsxtFunctions.getPolicyEdgeCluster(GetPolicyEdgeClusterArgs.builder()
            .displayName("ec")
            .build());

        final var node1 = NsxtFunctions.getPolicyEdgeNode(GetPolicyEdgeNodeArgs.builder()
            .edgeClusterPath(ec.applyValue(getPolicyEdgeClusterResult -> getPolicyEdgeClusterResult.path()))
            .memberIndex(0)
            .build());

    }
}

variables:
  ec:
    fn::invoke:
      function: nsxt:getPolicyEdgeCluster
      arguments:
        displayName: ec
  node1:
    fn::invoke:
      function: nsxt:getPolicyEdgeNode
      arguments:
        edgeClusterPath: ${ec.path}
        memberIndex: 0

function getPolicyEdgeNode(args: GetPolicyEdgeNodeArgs, opts?: InvokeOptions): Promise<GetPolicyEdgeNodeResult>
function getPolicyEdgeNodeOutput(args: GetPolicyEdgeNodeOutputArgs, opts?: InvokeOptions): Output<GetPolicyEdgeNodeResult>

def get_policy_edge_node(description: Optional[str] = None,
                         display_name: Optional[str] = None,
                         edge_cluster_path: Optional[str] = None,
                         id: Optional[str] = None,
                         member_index: Optional[float] = None,
                         opts: Optional[InvokeOptions] = None) -> GetPolicyEdgeNodeResult
def get_policy_edge_node_output(description: Optional[pulumi.Input[str]] = None,
                         display_name: Optional[pulumi.Input[str]] = None,
                         edge_cluster_path: Optional[pulumi.Input[str]] = None,
                         id: Optional[pulumi.Input[str]] = None,
                         member_index: Optional[pulumi.Input[float]] = None,
                         opts: Optional[InvokeOptions] = None) -> Output[GetPolicyEdgeNodeResult]

func GetPolicyEdgeNode(ctx *Context, args *GetPolicyEdgeNodeArgs, opts ...InvokeOption) (*GetPolicyEdgeNodeResult, error)
func GetPolicyEdgeNodeOutput(ctx *Context, args *GetPolicyEdgeNodeOutputArgs, opts ...InvokeOption) GetPolicyEdgeNodeResultOutput

public static class GetPolicyEdgeNode 
{
    public static Task<GetPolicyEdgeNodeResult> InvokeAsync(GetPolicyEdgeNodeArgs args, InvokeOptions? opts = null)
    public static Output<GetPolicyEdgeNodeResult> Invoke(GetPolicyEdgeNodeInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetPolicyEdgeNodeResult> getPolicyEdgeNode(GetPolicyEdgeNodeArgs args, InvokeOptions options)
public static Output<GetPolicyEdgeNodeResult> getPolicyEdgeNode(GetPolicyEdgeNodeArgs args, InvokeOptions options)

fn::invoke:
  function: nsxt:index/getPolicyEdgeNode:getPolicyEdgeNode
  arguments:
    # arguments dictionary