vsphere.getFolder

Explore with Pulumi AI

vSphere v4.14.0 published on Tuesday, May 20, 2025 by Pulumi

Example Usage

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

const datacenterFolderFolder = new vsphere.Folder("datacenter_folder", {
    path: "example-datacenter-folder",
    type: "datacenter",
});
const datacenterFolder = vsphere.getFolderOutput({
    path: pulumi.interpolate`/${datacenterFolderFolder.path}`,
});
const datacenterDatacenter = new vsphere.Datacenter("datacenter", {
    name: "example-datacenter",
    folder: datacenterFolder.apply(datacenterFolder => datacenterFolder.path),
}, {
    dependsOn: [datacenterFolder],
});
const datacenter = vsphere.getDatacenterOutput({
    name: datacenterDatacenter.name,
});
const vmFolderFolder = new vsphere.Folder("vm_folder", {
    path: "example-vm-folder",
    type: "vm",
    datacenterId: datacenter.apply(datacenter => datacenter.id),
});
const datastoreFolderFolder = new vsphere.Folder("datastore_folder", {
    path: "example-datastore-folder",
    type: "datastore",
    datacenterId: datacenter.apply(datacenter => datacenter.id),
});
const networkFolderFolder = new vsphere.Folder("network_folder", {
    path: "example-network-folder",
    type: "network",
    datacenterId: datacenter.apply(datacenter => datacenter.id),
});
const hostFolderFolder = new vsphere.Folder("host_folder", {
    path: "example-host-folder",
    type: "host",
    datacenterId: datacenter.apply(datacenter => datacenter.id),
});
const vmFolder = vsphere.getFolderOutput({
    path: pulumi.interpolate`/${datacenterFolderFolder.path}/${datacenterDatacenter.name}/vm/${vmFolderFolder.path}`,
});
const datastoreFolder = vsphere.getFolderOutput({
    path: pulumi.interpolate`/${datacenterFolderFolder.path}/${datacenterDatacenter.name}/datastore/${datastoreFolderFolder.path}`,
});
const networkFolder = vsphere.getFolderOutput({
    path: pulumi.interpolate`/${datacenterFolderFolder.path}/${datacenterDatacenter.name}/network/${networkFolderFolder.path}`,
});
const hostFolder = vsphere.getFolderOutput({
    path: pulumi.interpolate`/${datacenterFolderFolder.path}/${datacenterDatacenter.name}/host/${hostFolderFolder.path}`,
});
export const vmFolderId = vmFolder.apply(vmFolder => vmFolder.id);
export const datastoreFolderId = datastoreFolder.apply(datastoreFolder => datastoreFolder.id);
export const networkFolderId = networkFolder.apply(networkFolder => networkFolder.id);
export const hostFolderId = hostFolder.apply(hostFolder => hostFolder.id);
export const datacenterId = datacenter.apply(datacenter => datacenter.id);
export const datacenterFolderPath = datacenterFolderFolder.path;

import pulumi
import pulumi_vsphere as vsphere

datacenter_folder_folder = vsphere.Folder("datacenter_folder",
    path="example-datacenter-folder",
    type="datacenter")
datacenter_folder = vsphere.get_folder_output(path=datacenter_folder_folder.path.apply(lambda path: f"/{path}"))
datacenter_datacenter = vsphere.Datacenter("datacenter",
    name="example-datacenter",
    folder=datacenter_folder.path,
    opts = pulumi.ResourceOptions(depends_on=[datacenter_folder]))
datacenter = vsphere.get_datacenter_output(name=datacenter_datacenter.name)
vm_folder_folder = vsphere.Folder("vm_folder",
    path="example-vm-folder",
    type="vm",
    datacenter_id=datacenter.id)
datastore_folder_folder = vsphere.Folder("datastore_folder",
    path="example-datastore-folder",
    type="datastore",
    datacenter_id=datacenter.id)
network_folder_folder = vsphere.Folder("network_folder",
    path="example-network-folder",
    type="network",
    datacenter_id=datacenter.id)
host_folder_folder = vsphere.Folder("host_folder",
    path="example-host-folder",
    type="host",
    datacenter_id=datacenter.id)
vm_folder = vsphere.get_folder_output(path=pulumi.Output.all(
    datacenterFolderFolderPath=datacenter_folder_folder.path,
    name=datacenter_datacenter.name,
    vmFolderFolderPath=vm_folder_folder.path
).apply(lambda resolved_outputs: f"/{resolved_outputs['datacenterFolderFolderPath']}/{resolved_outputs['name']}/vm/{resolved_outputs['vmFolderFolderPath']}")
)
datastore_folder = vsphere.get_folder_output(path=pulumi.Output.all(
    datacenterFolderFolderPath=datacenter_folder_folder.path,
    name=datacenter_datacenter.name,
    datastoreFolderFolderPath=datastore_folder_folder.path
).apply(lambda resolved_outputs: f"/{resolved_outputs['datacenterFolderFolderPath']}/{resolved_outputs['name']}/datastore/{resolved_outputs['datastoreFolderFolderPath']}")
)
network_folder = vsphere.get_folder_output(path=pulumi.Output.all(
    datacenterFolderFolderPath=datacenter_folder_folder.path,
    name=datacenter_datacenter.name,
    networkFolderFolderPath=network_folder_folder.path
).apply(lambda resolved_outputs: f"/{resolved_outputs['datacenterFolderFolderPath']}/{resolved_outputs['name']}/network/{resolved_outputs['networkFolderFolderPath']}")
)
host_folder = vsphere.get_folder_output(path=pulumi.Output.all(
    datacenterFolderFolderPath=datacenter_folder_folder.path,
    name=datacenter_datacenter.name,
    hostFolderFolderPath=host_folder_folder.path
).apply(lambda resolved_outputs: f"/{resolved_outputs['datacenterFolderFolderPath']}/{resolved_outputs['name']}/host/{resolved_outputs['hostFolderFolderPath']}")
)
pulumi.export("vmFolderId", vm_folder.id)
pulumi.export("datastoreFolderId", datastore_folder.id)
pulumi.export("networkFolderId", network_folder.id)
pulumi.export("hostFolderId", host_folder.id)
pulumi.export("datacenterId", datacenter.id)
pulumi.export("datacenterFolderPath", datacenter_folder_folder.path)

package main

import (
	"fmt"

	"github.com/pulumi/pulumi-vsphere/sdk/v4/go/vsphere"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		datacenterFolderFolder, err := vsphere.NewFolder(ctx, "datacenter_folder", &vsphere.FolderArgs{
			Path: pulumi.String("example-datacenter-folder"),
			Type: pulumi.String("datacenter"),
		})
		if err != nil {
			return err
		}
		datacenterFolder := vsphere.LookupFolderOutput(ctx, vsphere.GetFolderOutputArgs{
			Path: datacenterFolderFolder.Path.ApplyT(func(path string) (string, error) {
				return fmt.Sprintf("/%v", path), nil
			}).(pulumi.StringOutput),
		}, nil)
		datacenterDatacenter, err := vsphere.NewDatacenter(ctx, "datacenter", &vsphere.DatacenterArgs{
			Name: pulumi.String("example-datacenter"),
			Folder: pulumi.String(datacenterFolder.ApplyT(func(datacenterFolder vsphere.GetFolderResult) (*string, error) {
				return &datacenterFolder.Path, nil
			}).(pulumi.StringPtrOutput)),
		}, pulumi.DependsOn([]pulumi.Resource{
			datacenterFolder,
		}))
		if err != nil {
			return err
		}
		datacenter := vsphere.LookupDatacenterOutput(ctx, vsphere.GetDatacenterOutputArgs{
			Name: datacenterDatacenter.Name,
		}, nil)
		vmFolderFolder, err := vsphere.NewFolder(ctx, "vm_folder", &vsphere.FolderArgs{
			Path: pulumi.String("example-vm-folder"),
			Type: pulumi.String("vm"),
			DatacenterId: pulumi.String(datacenter.ApplyT(func(datacenter vsphere.GetDatacenterResult) (*string, error) {
				return &datacenter.Id, nil
			}).(pulumi.StringPtrOutput)),
		})
		if err != nil {
			return err
		}
		datastoreFolderFolder, err := vsphere.NewFolder(ctx, "datastore_folder", &vsphere.FolderArgs{
			Path: pulumi.String("example-datastore-folder"),
			Type: pulumi.String("datastore"),
			DatacenterId: pulumi.String(datacenter.ApplyT(func(datacenter vsphere.GetDatacenterResult) (*string, error) {
				return &datacenter.Id, nil
			}).(pulumi.StringPtrOutput)),
		})
		if err != nil {
			return err
		}
		networkFolderFolder, err := vsphere.NewFolder(ctx, "network_folder", &vsphere.FolderArgs{
			Path: pulumi.String("example-network-folder"),
			Type: pulumi.String("network"),
			DatacenterId: pulumi.String(datacenter.ApplyT(func(datacenter vsphere.GetDatacenterResult) (*string, error) {
				return &datacenter.Id, nil
			}).(pulumi.StringPtrOutput)),
		})
		if err != nil {
			return err
		}
		hostFolderFolder, err := vsphere.NewFolder(ctx, "host_folder", &vsphere.FolderArgs{
			Path: pulumi.String("example-host-folder"),
			Type: pulumi.String("host"),
			DatacenterId: pulumi.String(datacenter.ApplyT(func(datacenter vsphere.GetDatacenterResult) (*string, error) {
				return &datacenter.Id, nil
			}).(pulumi.StringPtrOutput)),
		})
		if err != nil {
			return err
		}
		vmFolder := vsphere.LookupFolderOutput(ctx, vsphere.GetFolderOutputArgs{
			Path: pulumi.All(datacenterFolderFolder.Path, datacenterDatacenter.Name, vmFolderFolder.Path).ApplyT(func(_args []interface{}) (string, error) {
				datacenterFolderFolderPath := _args[0].(string)
				name := _args[1].(string)
				vmFolderFolderPath := _args[2].(string)
				return fmt.Sprintf("/%v/%v/vm/%v", datacenterFolderFolderPath, name, vmFolderFolderPath), nil
			}).(pulumi.StringOutput),
		}, nil)
		datastoreFolder := vsphere.LookupFolderOutput(ctx, vsphere.GetFolderOutputArgs{
			Path: pulumi.All(datacenterFolderFolder.Path, datacenterDatacenter.Name, datastoreFolderFolder.Path).ApplyT(func(_args []interface{}) (string, error) {
				datacenterFolderFolderPath := _args[0].(string)
				name := _args[1].(string)
				datastoreFolderFolderPath := _args[2].(string)
				return fmt.Sprintf("/%v/%v/datastore/%v", datacenterFolderFolderPath, name, datastoreFolderFolderPath), nil
			}).(pulumi.StringOutput),
		}, nil)
		networkFolder := vsphere.LookupFolderOutput(ctx, vsphere.GetFolderOutputArgs{
			Path: pulumi.All(datacenterFolderFolder.Path, datacenterDatacenter.Name, networkFolderFolder.Path).ApplyT(func(_args []interface{}) (string, error) {
				datacenterFolderFolderPath := _args[0].(string)
				name := _args[1].(string)
				networkFolderFolderPath := _args[2].(string)
				return fmt.Sprintf("/%v/%v/network/%v", datacenterFolderFolderPath, name, networkFolderFolderPath), nil
			}).(pulumi.StringOutput),
		}, nil)
		hostFolder := vsphere.LookupFolderOutput(ctx, vsphere.GetFolderOutputArgs{
			Path: pulumi.All(datacenterFolderFolder.Path, datacenterDatacenter.Name, hostFolderFolder.Path).ApplyT(func(_args []interface{}) (string, error) {
				datacenterFolderFolderPath := _args[0].(string)
				name := _args[1].(string)
				hostFolderFolderPath := _args[2].(string)
				return fmt.Sprintf("/%v/%v/host/%v", datacenterFolderFolderPath, name, hostFolderFolderPath), nil
			}).(pulumi.StringOutput),
		}, nil)
		ctx.Export("vmFolderId", vmFolder.ApplyT(func(vmFolder vsphere.GetFolderResult) (*string, error) {
			return &vmFolder.Id, nil
		}).(pulumi.StringPtrOutput))
		ctx.Export("datastoreFolderId", datastoreFolder.ApplyT(func(datastoreFolder vsphere.GetFolderResult) (*string, error) {
			return &datastoreFolder.Id, nil
		}).(pulumi.StringPtrOutput))
		ctx.Export("networkFolderId", networkFolder.ApplyT(func(networkFolder vsphere.GetFolderResult) (*string, error) {
			return &networkFolder.Id, nil
		}).(pulumi.StringPtrOutput))
		ctx.Export("hostFolderId", hostFolder.ApplyT(func(hostFolder vsphere.GetFolderResult) (*string, error) {
			return &hostFolder.Id, nil
		}).(pulumi.StringPtrOutput))
		ctx.Export("datacenterId", datacenter.ApplyT(func(datacenter vsphere.GetDatacenterResult) (*string, error) {
			return &datacenter.Id, nil
		}).(pulumi.StringPtrOutput))
		ctx.Export("datacenterFolderPath", datacenterFolderFolder.Path)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var datacenterFolderFolder = new VSphere.Folder("datacenter_folder", new()
    {
        Path = "example-datacenter-folder",
        Type = "datacenter",
    });

    var datacenterFolder = VSphere.GetFolder.Invoke(new()
    {
        Path = $"/{datacenterFolderFolder.Path}",
    });

    var datacenterDatacenter = new VSphere.Datacenter("datacenter", new()
    {
        Name = "example-datacenter",
        Folder = datacenterFolder.Apply(getFolderResult => getFolderResult.Path),
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            datacenterFolder,
        },
    });

    var datacenter = VSphere.GetDatacenter.Invoke(new()
    {
        Name = datacenterDatacenter.Name,
    });

    var vmFolderFolder = new VSphere.Folder("vm_folder", new()
    {
        Path = "example-vm-folder",
        Type = "vm",
        DatacenterId = datacenter.Apply(getDatacenterResult => getDatacenterResult.Id),
    });

    var datastoreFolderFolder = new VSphere.Folder("datastore_folder", new()
    {
        Path = "example-datastore-folder",
        Type = "datastore",
        DatacenterId = datacenter.Apply(getDatacenterResult => getDatacenterResult.Id),
    });

    var networkFolderFolder = new VSphere.Folder("network_folder", new()
    {
        Path = "example-network-folder",
        Type = "network",
        DatacenterId = datacenter.Apply(getDatacenterResult => getDatacenterResult.Id),
    });

    var hostFolderFolder = new VSphere.Folder("host_folder", new()
    {
        Path = "example-host-folder",
        Type = "host",
        DatacenterId = datacenter.Apply(getDatacenterResult => getDatacenterResult.Id),
    });

    var vmFolder = VSphere.GetFolder.Invoke(new()
    {
        Path = $"/{datacenterFolderFolder.Path}/{datacenterDatacenter.Name}/vm/{vmFolderFolder.Path}",
    });

    var datastoreFolder = VSphere.GetFolder.Invoke(new()
    {
        Path = $"/{datacenterFolderFolder.Path}/{datacenterDatacenter.Name}/datastore/{datastoreFolderFolder.Path}",
    });

    var networkFolder = VSphere.GetFolder.Invoke(new()
    {
        Path = $"/{datacenterFolderFolder.Path}/{datacenterDatacenter.Name}/network/{networkFolderFolder.Path}",
    });

    var hostFolder = VSphere.GetFolder.Invoke(new()
    {
        Path = $"/{datacenterFolderFolder.Path}/{datacenterDatacenter.Name}/host/{hostFolderFolder.Path}",
    });

    return new Dictionary<string, object?>
    {
        ["vmFolderId"] = vmFolder.Apply(getFolderResult => getFolderResult.Id),
        ["datastoreFolderId"] = datastoreFolder.Apply(getFolderResult => getFolderResult.Id),
        ["networkFolderId"] = networkFolder.Apply(getFolderResult => getFolderResult.Id),
        ["hostFolderId"] = hostFolder.Apply(getFolderResult => getFolderResult.Id),
        ["datacenterId"] = datacenter.Apply(getDatacenterResult => getDatacenterResult.Id),
        ["datacenterFolderPath"] = datacenterFolderFolder.Path,
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.vsphere.Folder;
import com.pulumi.vsphere.FolderArgs;
import com.pulumi.vsphere.VsphereFunctions;
import com.pulumi.vsphere.inputs.GetFolderArgs;
import com.pulumi.vsphere.Datacenter;
import com.pulumi.vsphere.DatacenterArgs;
import com.pulumi.vsphere.inputs.GetDatacenterArgs;
import com.pulumi.resources.CustomResourceOptions;
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) {
        var datacenterFolderFolder = new Folder("datacenterFolderFolder", FolderArgs.builder()
            .path("example-datacenter-folder")
            .type("datacenter")
            .build());

        final var datacenterFolder = VsphereFunctions.getFolder(GetFolderArgs.builder()
            .path(datacenterFolderFolder.path().applyValue(_path -> String.format("/%s", _path)))
            .build());

        var datacenterDatacenter = new Datacenter("datacenterDatacenter", DatacenterArgs.builder()
            .name("example-datacenter")
            .folder(datacenterFolder.applyValue(_datacenterFolder -> _datacenterFolder.path()))
            .build(), CustomResourceOptions.builder()
                .dependsOn(datacenterFolder)
                .build());

        final var datacenter = VsphereFunctions.getDatacenter(GetDatacenterArgs.builder()
            .name(datacenterDatacenter.name())
            .build());

        var vmFolderFolder = new Folder("vmFolderFolder", FolderArgs.builder()
            .path("example-vm-folder")
            .type("vm")
            .datacenterId(datacenter.applyValue(_datacenter -> _datacenter.id()))
            .build());

        var datastoreFolderFolder = new Folder("datastoreFolderFolder", FolderArgs.builder()
            .path("example-datastore-folder")
            .type("datastore")
            .datacenterId(datacenter.applyValue(_datacenter -> _datacenter.id()))
            .build());

        var networkFolderFolder = new Folder("networkFolderFolder", FolderArgs.builder()
            .path("example-network-folder")
            .type("network")
            .datacenterId(datacenter.applyValue(_datacenter -> _datacenter.id()))
            .build());

        var hostFolderFolder = new Folder("hostFolderFolder", FolderArgs.builder()
            .path("example-host-folder")
            .type("host")
            .datacenterId(datacenter.applyValue(_datacenter -> _datacenter.id()))
            .build());

        final var vmFolder = VsphereFunctions.getFolder(GetFolderArgs.builder()
            .path(Output.tuple(datacenterFolderFolder.path(), datacenterDatacenter.name(), vmFolderFolder.path()).applyValue(values -> {
                var datacenterFolderFolderPath = values.t1;
                var name = values.t2;
                var vmFolderFolderPath = values.t3;
                return String.format("/%s/%s/vm/%s", datacenterFolderFolderPath,name,vmFolderFolderPath);
            }))
            .build());

        final var datastoreFolder = VsphereFunctions.getFolder(GetFolderArgs.builder()
            .path(Output.tuple(datacenterFolderFolder.path(), datacenterDatacenter.name(), datastoreFolderFolder.path()).applyValue(values -> {
                var datacenterFolderFolderPath = values.t1;
                var name = values.t2;
                var datastoreFolderFolderPath = values.t3;
                return String.format("/%s/%s/datastore/%s", datacenterFolderFolderPath,name,datastoreFolderFolderPath);
            }))
            .build());

        final var networkFolder = VsphereFunctions.getFolder(GetFolderArgs.builder()
            .path(Output.tuple(datacenterFolderFolder.path(), datacenterDatacenter.name(), networkFolderFolder.path()).applyValue(values -> {
                var datacenterFolderFolderPath = values.t1;
                var name = values.t2;
                var networkFolderFolderPath = values.t3;
                return String.format("/%s/%s/network/%s", datacenterFolderFolderPath,name,networkFolderFolderPath);
            }))
            .build());

        final var hostFolder = VsphereFunctions.getFolder(GetFolderArgs.builder()
            .path(Output.tuple(datacenterFolderFolder.path(), datacenterDatacenter.name(), hostFolderFolder.path()).applyValue(values -> {
                var datacenterFolderFolderPath = values.t1;
                var name = values.t2;
                var hostFolderFolderPath = values.t3;
                return String.format("/%s/%s/host/%s", datacenterFolderFolderPath,name,hostFolderFolderPath);
            }))
            .build());

        ctx.export("vmFolderId", vmFolder.applyValue(_vmFolder -> _vmFolder.id()));
        ctx.export("datastoreFolderId", datastoreFolder.applyValue(_datastoreFolder -> _datastoreFolder.id()));
        ctx.export("networkFolderId", networkFolder.applyValue(_networkFolder -> _networkFolder.id()));
        ctx.export("hostFolderId", hostFolder.applyValue(_hostFolder -> _hostFolder.id()));
        ctx.export("datacenterId", datacenter.applyValue(_datacenter -> _datacenter.id()));
        ctx.export("datacenterFolderPath", datacenterFolderFolder.path());
    }
}

resources:
  datacenterFolderFolder:
    type: vsphere:Folder
    name: datacenter_folder
    properties:
      path: example-datacenter-folder
      type: datacenter
  datacenterDatacenter:
    type: vsphere:Datacenter
    name: datacenter
    properties:
      name: example-datacenter
      folder: ${datacenterFolder.path}
    options:
      dependsOn:
        - ${datacenterFolder}
  vmFolderFolder:
    type: vsphere:Folder
    name: vm_folder
    properties:
      path: example-vm-folder
      type: vm
      datacenterId: ${datacenter.id}
  datastoreFolderFolder:
    type: vsphere:Folder
    name: datastore_folder
    properties:
      path: example-datastore-folder
      type: datastore
      datacenterId: ${datacenter.id}
  networkFolderFolder:
    type: vsphere:Folder
    name: network_folder
    properties:
      path: example-network-folder
      type: network
      datacenterId: ${datacenter.id}
  hostFolderFolder:
    type: vsphere:Folder
    name: host_folder
    properties:
      path: example-host-folder
      type: host
      datacenterId: ${datacenter.id}
variables:
  datacenterFolder:
    fn::invoke:
      function: vsphere:getFolder
      arguments:
        path: /${datacenterFolderFolder.path}
  datacenter:
    fn::invoke:
      function: vsphere:getDatacenter
      arguments:
        name: ${datacenterDatacenter.name}
  vmFolder:
    fn::invoke:
      function: vsphere:getFolder
      arguments:
        path: /${datacenterFolderFolder.path}/${datacenterDatacenter.name}/vm/${vmFolderFolder.path}
  datastoreFolder:
    fn::invoke:
      function: vsphere:getFolder
      arguments:
        path: /${datacenterFolderFolder.path}/${datacenterDatacenter.name}/datastore/${datastoreFolderFolder.path}
  networkFolder:
    fn::invoke:
      function: vsphere:getFolder
      arguments:
        path: /${datacenterFolderFolder.path}/${datacenterDatacenter.name}/network/${networkFolderFolder.path}
  hostFolder:
    fn::invoke:
      function: vsphere:getFolder
      arguments:
        path: /${datacenterFolderFolder.path}/${datacenterDatacenter.name}/host/${hostFolderFolder.path}
outputs:
  vmFolderId: ${vmFolder.id}
  datastoreFolderId: ${datastoreFolder.id}
  networkFolderId: ${networkFolder.id}
  hostFolderId: ${hostFolder.id}
  datacenterId: ${datacenter.id}
  datacenterFolderPath: ${datacenterFolderFolder.path}

Using getFolder

Two invocation forms are available. The direct form accepts plain arguments and either blocks until the result value is available, or returns a Promise-wrapped result. The output form accepts Input-wrapped arguments and returns an Output-wrapped result.

function getFolder(args: GetFolderArgs, opts?: InvokeOptions): Promise<GetFolderResult>
function getFolderOutput(args: GetFolderOutputArgs, opts?: InvokeOptions): Output<GetFolderResult>

def get_folder(path: Optional[str] = None,
               opts: Optional[InvokeOptions] = None) -> GetFolderResult
def get_folder_output(path: Optional[pulumi.Input[str]] = None,
               opts: Optional[InvokeOptions] = None) -> Output[GetFolderResult]

func LookupFolder(ctx *Context, args *LookupFolderArgs, opts ...InvokeOption) (*LookupFolderResult, error)
func LookupFolderOutput(ctx *Context, args *LookupFolderOutputArgs, opts ...InvokeOption) LookupFolderResultOutput

> Note: This function is named LookupFolder in the Go SDK.

public static class GetFolder 
{
    public static Task<GetFolderResult> InvokeAsync(GetFolderArgs args, InvokeOptions? opts = null)
    public static Output<GetFolderResult> Invoke(GetFolderInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetFolderResult> getFolder(GetFolderArgs args, InvokeOptions options)
public static Output<GetFolderResult> getFolder(GetFolderArgs args, InvokeOptions options)

fn::invoke:
  function: vsphere:index/getFolder:getFolder
  arguments:
    # arguments dictionary

The following arguments are supported:

Path string

The absolute path of the folder. For example, given a default datacenter of default-dc, a folder of type vm, and a folder name of example-vm-folder, the resulting path would be /default-dc/vm/example-vm-folder.

For nested datacenters, include the full hierarchy in the path. For example, if datacenter default-dc is inside folder parent-folder, the path to a VM folder would be /parent-folder/default-dc/vm/example-vm-folder.