vcd.getNsxtEdgeCluster

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

const existing = vcd.getOrgVdc({
    org: "my-org",
    name: "nsxt-vdc-1",
});
const first = existing.then(existing => vcd.getNsxtEdgeCluster({
    org: "my-org",
    vdcId: existing.id,
    name: "edge-cluster-one",
}));

import pulumi
import pulumi_vcd as vcd

existing = vcd.get_org_vdc(org="my-org",
    name="nsxt-vdc-1")
first = vcd.get_nsxt_edge_cluster(org="my-org",
    vdc_id=existing.id,
    name="edge-cluster-one")

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		existing, err := vcd.LookupOrgVdc(ctx, &vcd.LookupOrgVdcArgs{
			Org:  pulumi.StringRef("my-org"),
			Name: "nsxt-vdc-1",
		}, nil)
		if err != nil {
			return err
		}
		_, err = vcd.GetNsxtEdgeCluster(ctx, &vcd.GetNsxtEdgeClusterArgs{
			Org:   pulumi.StringRef("my-org"),
			VdcId: pulumi.StringRef(existing.Id),
			Name:  "edge-cluster-one",
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var existing = Vcd.GetOrgVdc.Invoke(new()
    {
        Org = "my-org",
        Name = "nsxt-vdc-1",
    });

    var first = Vcd.GetNsxtEdgeCluster.Invoke(new()
    {
        Org = "my-org",
        VdcId = existing.Apply(getOrgVdcResult => getOrgVdcResult.Id),
        Name = "edge-cluster-one",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.vcd.VcdFunctions;
import com.pulumi.vcd.inputs.GetOrgVdcArgs;
import com.pulumi.vcd.inputs.GetNsxtEdgeClusterArgs;
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 existing = VcdFunctions.getOrgVdc(GetOrgVdcArgs.builder()
            .org("my-org")
            .name("nsxt-vdc-1")
            .build());

        final var first = VcdFunctions.getNsxtEdgeCluster(GetNsxtEdgeClusterArgs.builder()
            .org("my-org")
            .vdcId(existing.applyValue(getOrgVdcResult -> getOrgVdcResult.id()))
            .name("edge-cluster-one")
            .build());

    }
}

variables:
  existing:
    fn::invoke:
      function: vcd:getOrgVdc
      arguments:
        org: my-org
        name: nsxt-vdc-1
  first:
    fn::invoke:
      function: vcd:getNsxtEdgeCluster
      arguments:
        org: my-org
        vdcId: ${existing.id}
        name: edge-cluster-one

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

const existing = vcd.getVdcGroup({
    org: "my-org",
    name: "nsxt-vdc-group-1",
});
const first = existing.then(existing => vcd.getNsxtEdgeCluster({
    org: "my-org",
    vdcGroupId: existing.id,
    name: "edge-cluster-one",
}));

import pulumi
import pulumi_vcd as vcd

existing = vcd.get_vdc_group(org="my-org",
    name="nsxt-vdc-group-1")
first = vcd.get_nsxt_edge_cluster(org="my-org",
    vdc_group_id=existing.id,
    name="edge-cluster-one")

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		existing, err := vcd.LookupVdcGroup(ctx, &vcd.LookupVdcGroupArgs{
			Org:  pulumi.StringRef("my-org"),
			Name: pulumi.StringRef("nsxt-vdc-group-1"),
		}, nil)
		if err != nil {
			return err
		}
		_, err = vcd.GetNsxtEdgeCluster(ctx, &vcd.GetNsxtEdgeClusterArgs{
			Org:        pulumi.StringRef("my-org"),
			VdcGroupId: pulumi.StringRef(existing.Id),
			Name:       "edge-cluster-one",
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var existing = Vcd.GetVdcGroup.Invoke(new()
    {
        Org = "my-org",
        Name = "nsxt-vdc-group-1",
    });

    var first = Vcd.GetNsxtEdgeCluster.Invoke(new()
    {
        Org = "my-org",
        VdcGroupId = existing.Apply(getVdcGroupResult => getVdcGroupResult.Id),
        Name = "edge-cluster-one",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.vcd.VcdFunctions;
import com.pulumi.vcd.inputs.GetVdcGroupArgs;
import com.pulumi.vcd.inputs.GetNsxtEdgeClusterArgs;
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 existing = VcdFunctions.getVdcGroup(GetVdcGroupArgs.builder()
            .org("my-org")
            .name("nsxt-vdc-group-1")
            .build());

        final var first = VcdFunctions.getNsxtEdgeCluster(GetNsxtEdgeClusterArgs.builder()
            .org("my-org")
            .vdcGroupId(existing.applyValue(getVdcGroupResult -> getVdcGroupResult.id()))
            .name("edge-cluster-one")
            .build());

    }
}

variables:
  existing:
    fn::invoke:
      function: vcd:getVdcGroup
      arguments:
        org: my-org
        name: nsxt-vdc-group-1
  first:
    fn::invoke:
      function: vcd:getNsxtEdgeCluster
      arguments:
        org: my-org
        vdcGroupId: ${existing.id}
        name: edge-cluster-one

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

const nsxt_pvdc = vcd.getProviderVdc({
    name: "nsxt-provider-vdc",
});
const first = nsxt_pvdc.then(nsxt_pvdc => vcd.getNsxtEdgeCluster({
    org: "my-org",
    providerVdcId: nsxt_pvdc.id,
    name: "edge-cluster-one",
}));

import pulumi
import pulumi_vcd as vcd

nsxt_pvdc = vcd.get_provider_vdc(name="nsxt-provider-vdc")
first = vcd.get_nsxt_edge_cluster(org="my-org",
    provider_vdc_id=nsxt_pvdc.id,
    name="edge-cluster-one")

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		nsxt_pvdc, err := vcd.LookupProviderVdc(ctx, &vcd.LookupProviderVdcArgs{
			Name: "nsxt-provider-vdc",
		}, nil)
		if err != nil {
			return err
		}
		_, err = vcd.GetNsxtEdgeCluster(ctx, &vcd.GetNsxtEdgeClusterArgs{
			Org:           pulumi.StringRef("my-org"),
			ProviderVdcId: pulumi.StringRef(nsxt_pvdc.Id),
			Name:          "edge-cluster-one",
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var nsxt_pvdc = Vcd.GetProviderVdc.Invoke(new()
    {
        Name = "nsxt-provider-vdc",
    });

    var first = Vcd.GetNsxtEdgeCluster.Invoke(new()
    {
        Org = "my-org",
        ProviderVdcId = nsxt_pvdc.Apply(getProviderVdcResult => getProviderVdcResult.Id),
        Name = "edge-cluster-one",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.vcd.VcdFunctions;
import com.pulumi.vcd.inputs.GetProviderVdcArgs;
import com.pulumi.vcd.inputs.GetNsxtEdgeClusterArgs;
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 nsxt-pvdc = VcdFunctions.getProviderVdc(GetProviderVdcArgs.builder()
            .name("nsxt-provider-vdc")
            .build());

        final var first = VcdFunctions.getNsxtEdgeCluster(GetNsxtEdgeClusterArgs.builder()
            .org("my-org")
            .providerVdcId(nsxt_pvdc.id())
            .name("edge-cluster-one")
            .build());

    }
}

variables:
  nsxt-pvdc:
    fn::invoke:
      function: vcd:getProviderVdc
      arguments:
        name: nsxt-provider-vdc
  first:
    fn::invoke:
      function: vcd:getNsxtEdgeCluster
      arguments:
        org: my-org
        providerVdcId: ${["nsxt-pvdc"].id}
        name: edge-cluster-one

function getNsxtEdgeCluster(args: GetNsxtEdgeClusterArgs, opts?: InvokeOptions): Promise<GetNsxtEdgeClusterResult>
function getNsxtEdgeClusterOutput(args: GetNsxtEdgeClusterOutputArgs, opts?: InvokeOptions): Output<GetNsxtEdgeClusterResult>

def get_nsxt_edge_cluster(id: Optional[str] = None,
                          name: Optional[str] = None,
                          org: Optional[str] = None,
                          provider_vdc_id: Optional[str] = None,
                          vdc: Optional[str] = None,
                          vdc_group_id: Optional[str] = None,
                          vdc_id: Optional[str] = None,
                          opts: Optional[InvokeOptions] = None) -> GetNsxtEdgeClusterResult
def get_nsxt_edge_cluster_output(id: Optional[pulumi.Input[str]] = None,
                          name: Optional[pulumi.Input[str]] = None,
                          org: Optional[pulumi.Input[str]] = None,
                          provider_vdc_id: Optional[pulumi.Input[str]] = None,
                          vdc: Optional[pulumi.Input[str]] = None,
                          vdc_group_id: Optional[pulumi.Input[str]] = None,
                          vdc_id: Optional[pulumi.Input[str]] = None,
                          opts: Optional[InvokeOptions] = None) -> Output[GetNsxtEdgeClusterResult]

func GetNsxtEdgeCluster(ctx *Context, args *GetNsxtEdgeClusterArgs, opts ...InvokeOption) (*GetNsxtEdgeClusterResult, error)
func GetNsxtEdgeClusterOutput(ctx *Context, args *GetNsxtEdgeClusterOutputArgs, opts ...InvokeOption) GetNsxtEdgeClusterResultOutput

public static class GetNsxtEdgeCluster 
{
    public static Task<GetNsxtEdgeClusterResult> InvokeAsync(GetNsxtEdgeClusterArgs args, InvokeOptions? opts = null)
    public static Output<GetNsxtEdgeClusterResult> Invoke(GetNsxtEdgeClusterInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetNsxtEdgeClusterResult> getNsxtEdgeCluster(GetNsxtEdgeClusterArgs args, InvokeOptions options)
public static Output<GetNsxtEdgeClusterResult> getNsxtEdgeCluster(GetNsxtEdgeClusterArgs args, InvokeOptions options)

fn::invoke:
  function: vcd:index/getNsxtEdgeCluster:getNsxtEdgeCluster
  arguments:
    # arguments dictionary