vcd.getVcenter

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

const vc = vcd.getVcenter({
    name: "vcenter-one",
});

import pulumi
import pulumi_vcd as vcd

vc = vcd.get_vcenter(name="vcenter-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 {
		_, err := vcd.GetVcenter(ctx, &vcd.GetVcenterArgs{
			Name: "vcenter-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 vc = Vcd.GetVcenter.Invoke(new()
    {
        Name = "vcenter-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.GetVcenterArgs;
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 vc = VcdFunctions.getVcenter(GetVcenterArgs.builder()
            .name("vcenter-one")
            .build());

    }
}

variables:
  vc:
    fn::invoke:
      function: vcd:getVcenter
      arguments:
        name: vcenter-one

function getVcenter(args: GetVcenterArgs, opts?: InvokeOptions): Promise<GetVcenterResult>
function getVcenterOutput(args: GetVcenterOutputArgs, opts?: InvokeOptions): Output<GetVcenterResult>

def get_vcenter(id: Optional[str] = None,
                name: Optional[str] = None,
                opts: Optional[InvokeOptions] = None) -> GetVcenterResult
def get_vcenter_output(id: Optional[pulumi.Input[str]] = None,
                name: Optional[pulumi.Input[str]] = None,
                opts: Optional[InvokeOptions] = None) -> Output[GetVcenterResult]

func GetVcenter(ctx *Context, args *GetVcenterArgs, opts ...InvokeOption) (*GetVcenterResult, error)
func GetVcenterOutput(ctx *Context, args *GetVcenterOutputArgs, opts ...InvokeOption) GetVcenterResultOutput

public static class GetVcenter 
{
    public static Task<GetVcenterResult> InvokeAsync(GetVcenterArgs args, InvokeOptions? opts = null)
    public static Output<GetVcenterResult> Invoke(GetVcenterInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetVcenterResult> getVcenter(GetVcenterArgs args, InvokeOptions options)
public static Output<GetVcenterResult> getVcenter(GetVcenterArgs args, InvokeOptions options)

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