netbox.getClusters

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

// Get all clusters of a specific type
const vmware = netbox.getClusterType({
    name: "VMware ESXi",
});
const vmwareClusters = vmware.then(vmware => netbox.getClusters({
    filters: [{
        name: "cluster_type_id",
        value: vmware.id,
    }],
}));
// Get clusters by name regex
const prodClusters = netbox.getClusters({
    nameRegex: "prod-.*",
});
// Get clusters at a specific site
const siteClusters = netbox.getClusters({
    filters: [{
        name: "site_id",
        value: main.id,
    }],
});

import pulumi
import pulumi_netbox as netbox

# Get all clusters of a specific type
vmware = netbox.get_cluster_type(name="VMware ESXi")
vmware_clusters = netbox.get_clusters(filters=[{
    "name": "cluster_type_id",
    "value": vmware.id,
}])
# Get clusters by name regex
prod_clusters = netbox.get_clusters(name_regex="prod-.*")
# Get clusters at a specific site
site_clusters = netbox.get_clusters(filters=[{
    "name": "site_id",
    "value": main["id"],
}])

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Get all clusters of a specific type
		vmware, err := netbox.LookupClusterType(ctx, &netbox.LookupClusterTypeArgs{
			Name: "VMware ESXi",
		}, nil)
		if err != nil {
			return err
		}
		_, err = netbox.GetClusters(ctx, &netbox.GetClustersArgs{
			Filters: []netbox.GetClustersFilter{
				{
					Name:  "cluster_type_id",
					Value: vmware.Id,
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		// Get clusters by name regex
		_, err = netbox.GetClusters(ctx, &netbox.GetClustersArgs{
			NameRegex: pulumi.StringRef("prod-.*"),
		}, nil)
		if err != nil {
			return err
		}
		// Get clusters at a specific site
		_, err = netbox.GetClusters(ctx, &netbox.GetClustersArgs{
			Filters: []netbox.GetClustersFilter{
				{
					Name:  "site_id",
					Value: main.Id,
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    // Get all clusters of a specific type
    var vmware = Netbox.GetClusterType.Invoke(new()
    {
        Name = "VMware ESXi",
    });

    var vmwareClusters = Netbox.GetClusters.Invoke(new()
    {
        Filters = new[]
        {
            new Netbox.Inputs.GetClustersFilterInputArgs
            {
                Name = "cluster_type_id",
                Value = vmware.Apply(getClusterTypeResult => getClusterTypeResult.Id),
            },
        },
    });

    // Get clusters by name regex
    var prodClusters = Netbox.GetClusters.Invoke(new()
    {
        NameRegex = "prod-.*",
    });

    // Get clusters at a specific site
    var siteClusters = Netbox.GetClusters.Invoke(new()
    {
        Filters = new[]
        {
            new Netbox.Inputs.GetClustersFilterInputArgs
            {
                Name = "site_id",
                Value = main.Id,
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.netbox.NetboxFunctions;
import com.pulumi.netbox.inputs.GetClusterTypeArgs;
import com.pulumi.netbox.inputs.GetClustersArgs;
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) {
        // Get all clusters of a specific type
        final var vmware = NetboxFunctions.getClusterType(GetClusterTypeArgs.builder()
            .name("VMware ESXi")
            .build());

        final var vmwareClusters = NetboxFunctions.getClusters(GetClustersArgs.builder()
            .filters(GetClustersFilterArgs.builder()
                .name("cluster_type_id")
                .value(vmware.id())
                .build())
            .build());

        // Get clusters by name regex
        final var prodClusters = NetboxFunctions.getClusters(GetClustersArgs.builder()
            .nameRegex("prod-.*")
            .build());

        // Get clusters at a specific site
        final var siteClusters = NetboxFunctions.getClusters(GetClustersArgs.builder()
            .filters(GetClustersFilterArgs.builder()
                .name("site_id")
                .value(main.id())
                .build())
            .build());

    }
}

variables:
  # Get all clusters of a specific type
  vmware:
    fn::invoke:
      function: netbox:getClusterType
      arguments:
        name: VMware ESXi
  vmwareClusters:
    fn::invoke:
      function: netbox:getClusters
      arguments:
        filters:
          - name: cluster_type_id
            value: ${vmware.id}
  # Get clusters by name regex
  prodClusters:
    fn::invoke:
      function: netbox:getClusters
      arguments:
        nameRegex: prod-.*
  # Get clusters at a specific site
  siteClusters:
    fn::invoke:
      function: netbox:getClusters
      arguments:
        filters:
          - name: site_id
            value: ${main.id}

function getClusters(args: GetClustersArgs, opts?: InvokeOptions): Promise<GetClustersResult>
function getClustersOutput(args: GetClustersOutputArgs, opts?: InvokeOptions): Output<GetClustersResult>

def get_clusters(filters: Optional[Sequence[GetClustersFilter]] = None,
                 id: Optional[str] = None,
                 limit: Optional[float] = None,
                 name_regex: Optional[str] = None,
                 opts: Optional[InvokeOptions] = None) -> GetClustersResult
def get_clusters_output(filters: Optional[pulumi.Input[Sequence[pulumi.Input[GetClustersFilterArgs]]]] = None,
                 id: Optional[pulumi.Input[str]] = None,
                 limit: Optional[pulumi.Input[float]] = None,
                 name_regex: Optional[pulumi.Input[str]] = None,
                 opts: Optional[InvokeOptions] = None) -> Output[GetClustersResult]

func GetClusters(ctx *Context, args *GetClustersArgs, opts ...InvokeOption) (*GetClustersResult, error)
func GetClustersOutput(ctx *Context, args *GetClustersOutputArgs, opts ...InvokeOption) GetClustersResultOutput

public static class GetClusters 
{
    public static Task<GetClustersResult> InvokeAsync(GetClustersArgs args, InvokeOptions? opts = null)
    public static Output<GetClustersResult> Invoke(GetClustersInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetClustersResult> getClusters(GetClustersArgs args, InvokeOptions options)
public static Output<GetClustersResult> getClusters(GetClustersArgs args, InvokeOptions options)

fn::invoke:
  function: netbox:index/getClusters:getClusters
  arguments:
    # arguments dictionary