getNodebalancers

Linode v6.8.0, Oct 21 26

Viewing docs for Linode v6.8.0
published on Wednesday, Oct 21, 2026 by Pulumi

Schema (JSON)

pulumi/pulumi-linode

Viewing docs for Linode v6.8.0
published on Wednesday, Oct 21, 2026 by Pulumi

Schema (JSON)

pulumi/pulumi-linode

Example Usage

The following example shows how one might use this data source to access information about a Linode NodeBalancer.

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

const specific_nodebalancers = linode.getNodebalancers({
    filters: [
        {
            name: "label",
            values: ["my-nodebalancer"],
        },
        {
            name: "region",
            values: ["us-iad"],
        },
    ],
});
export const nodebalancerId = specific_nodebalancers.then(specific_nodebalancers => specific_nodebalancers.nodebalancers?.[0]?.id);

import pulumi
import pulumi_linode as linode

specific_nodebalancers = linode.get_nodebalancers(filters=[
    {
        "name": "label",
        "values": ["my-nodebalancer"],
    },
    {
        "name": "region",
        "values": ["us-iad"],
    },
])
pulumi.export("nodebalancerId", specific_nodebalancers.nodebalancers[0].id)

package main

import (
	"github.com/pulumi/pulumi-linode/sdk/v6/go/linode"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		specific_nodebalancers, err := linode.GetNodebalancers(ctx, &linode.GetNodebalancersArgs{
			Filters: []linode.GetNodebalancersFilter{
				{
					Name: "label",
					Values: []string{
						"my-nodebalancer",
					},
				},
				{
					Name: "region",
					Values: []string{
						"us-iad",
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("nodebalancerId", specific_nodebalancers.Nodebalancers[0].Id)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var specific_nodebalancers = Linode.GetNodebalancers.Invoke(new()
    {
        Filters = new[]
        {
            new Linode.Inputs.GetNodebalancersFilterInputArgs
            {
                Name = "label",
                Values = new[]
                {
                    "my-nodebalancer",
                },
            },
            new Linode.Inputs.GetNodebalancersFilterInputArgs
            {
                Name = "region",
                Values = new[]
                {
                    "us-iad",
                },
            },
        },
    });

    return new Dictionary<string, object?>
    {
        ["nodebalancerId"] = specific_nodebalancers.Apply(specific_nodebalancers => specific_nodebalancers.Apply(getNodebalancersResult => getNodebalancersResult.Nodebalancers[0]?.Id)),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.linode.LinodeFunctions;
import com.pulumi.linode.inputs.GetNodebalancersArgs;
import com.pulumi.linode.inputs.GetNodebalancersFilterArgs;
import java.util.ArrayList;
import java.util.Arrays;
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 specific-nodebalancers = LinodeFunctions.getNodebalancers(GetNodebalancersArgs.builder()
            .filters(            
                GetNodebalancersFilterArgs.builder()
                    .name("label")
                    .values("my-nodebalancer")
                    .build(),
                GetNodebalancersFilterArgs.builder()
                    .name("region")
                    .values("us-iad")
                    .build())
            .build());

        ctx.export("nodebalancerId", specific_nodebalancers.nodebalancers()[0].id());
    }
}

variables:
  specific-nodebalancers:
    fn::invoke:
      function: linode:getNodebalancers
      arguments:
        filters:
          - name: label
            values:
              - my-nodebalancer
          - name: region
            values:
              - us-iad
outputs:
  nodebalancerId: ${["specific-nodebalancers"].nodebalancers[0].id}

terraform {
  required_providers {
    linode = {
      source = "pulumi/linode"
    }
  }
}

data "linode_nodebalancers" "specific-nodebalancers" {
  filters {
    name   = "label"
    values = ["my-nodebalancer"]
  }
  filters {
    name   = "region"
    values = ["us-iad"]
  }
}

output "nodebalancerId" {
  value = data.linode_nodebalancers.specific-nodebalancers.nodebalancers[0].id
}

Filterable Fields

label
tags
ipv4
ipv6
hostname
region
clientConnThrottle
type (client-side)
backendConnectivity (client-side)

Using getNodebalancers

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 getNodebalancers(args: GetNodebalancersArgs, opts?: InvokeOptions): Promise<GetNodebalancersResult>
function getNodebalancersOutput(args: GetNodebalancersOutputArgs, opts?: InvokeOutputOptions): Output<GetNodebalancersResult>

def get_nodebalancers(filters: Optional[Sequence[GetNodebalancersFilter]] = None,
                      order: Optional[str] = None,
                      order_by: Optional[str] = None,
                      opts: Optional[InvokeOptions] = None) -> GetNodebalancersResult
def get_nodebalancers_output(filters: pulumi.Input[Optional[Sequence[pulumi.Input[GetNodebalancersFilterArgs]]]] = None,
                      order: pulumi.Input[Optional[str]] = None,
                      order_by: pulumi.Input[Optional[str]] = None,
                      opts: Optional[InvokeOutputOptions] = None) -> Output[GetNodebalancersResult]

func GetNodebalancers(ctx *Context, args *GetNodebalancersArgs, opts ...InvokeOption) (*GetNodebalancersResult, error)
func GetNodebalancersOutput(ctx *Context, args *GetNodebalancersOutputArgs, opts ...InvokeOption) GetNodebalancersResultOutput

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

public static class GetNodebalancers 
{
    public static Task<GetNodebalancersResult> InvokeAsync(GetNodebalancersArgs args, InvokeOptions? opts = null)
    public static Output<GetNodebalancersResult> Invoke(GetNodebalancersInvokeArgs args, InvokeOptions? opts = null)
    public static Output<GetNodebalancersResult> Invoke(GetNodebalancersInvokeArgs args, InvokeOutputOptions opts)
}

public static CompletableFuture<GetNodebalancersResult> getNodebalancers(GetNodebalancersArgs args, InvokeOptions options)
public static Output<GetNodebalancersResult> getNodebalancers(GetNodebalancersArgs args, InvokeOptions options)
public static Output<GetNodebalancersResult> getNodebalancers(GetNodebalancersArgs args, InvokeOutputOptions options)

fn::invoke:
  function: linode:index/getNodebalancers:getNodebalancers
  arguments:
    # arguments dictionary

data "linode_get_nodebalancers" "name" {
    # arguments
}

The following arguments are supported:

Filters List<GetNodebalancersFilter>
Order string: The order in which results should be returned. (asc, desc; default desc)
OrderBy string: The attribute to order the results by. See the Filterable Fields section for a list of valid fields.

Filters []GetNodebalancersFilter
Order string: The order in which results should be returned. (asc, desc; default desc)
OrderBy string: The attribute to order the results by. See the Filterable Fields section for a list of valid fields.

filters list(object)
order string: The order in which results should be returned. (asc, desc; default desc)
order_by string: The attribute to order the results by. See the Filterable Fields section for a list of valid fields.

filters List<GetNodebalancersFilter>
order String: The order in which results should be returned. (asc, desc; default desc)
orderBy String: The attribute to order the results by. See the Filterable Fields section for a list of valid fields.

filters GetNodebalancersFilter[]
order string: The order in which results should be returned. (asc, desc; default desc)
orderBy string: The attribute to order the results by. See the Filterable Fields section for a list of valid fields.

filters Sequence[GetNodebalancersFilter]
order str: The order in which results should be returned. (asc, desc; default desc)
order_by str: The attribute to order the results by. See the Filterable Fields section for a list of valid fields.

filters List<Property Map>
order String: The order in which results should be returned. (asc, desc; default desc)
orderBy String: The attribute to order the results by. See the Filterable Fields section for a list of valid fields.