getCatalogNodes

Consul v3.13.3, Nov 19 25

Consul v3.13.3 published on Wednesday, Nov 19, 2025 by Pulumi

Schema (JSON)

pulumi/pulumi-consul

Consul v3.13.3 published on Wednesday, Nov 19, 2025 by Pulumi

Schema (JSON)

pulumi/pulumi-consul

Example Usage

import * as pulumi from "@pulumi/pulumi";
import * as consul from "@pulumi/consul";
import * as example from "@pulumi/example";
import * as std from "@pulumi/std";

const read_dc1_nodes = consul.getNodes({
    queryOptions: [{
        datacenter: "dc1",
    }],
});
// Set the description to a whitespace delimited list of the node names
const app = new example.index.Resource("app", {description: std.join({
    separator: " ",
    input: std.formatlist({
        input: "%s",
        args: [nodeNames],
    }).result,
}).result});

import pulumi
import pulumi_consul as consul
import pulumi_example as example
import pulumi_std as std

read_dc1_nodes = consul.get_nodes(query_options=[{
    "datacenter": "dc1",
}])
# Set the description to a whitespace delimited list of the node names
app = example.index.Resource("app", description=std.join(separator= ,
    input=std.formatlist(input=%s,
        args=[node_names]).result).result)

package main

import (
	"github.com/pulumi/pulumi-consul/sdk/v3/go/consul"
	"github.com/pulumi/pulumi-example/sdk/go/example"
	"github.com/pulumi/pulumi-std/sdk/go/std"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := consul.GetNodes(ctx, &consul.GetNodesArgs{
			QueryOptions: []consul.GetNodesQueryOption{
				{
					Datacenter: pulumi.StringRef("dc1"),
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		// Set the description to a whitespace delimited list of the node names
		_, err = example.NewResource(ctx, "app", &example.ResourceArgs{
			Description: std.Join(ctx, &std.JoinArgs{
				Separator: " ",
				Input: std.Formatlist(ctx, &std.FormatlistArgs{
					Input: "%s",
					Args: []interface{}{
						nodeNames,
					},
				}, nil).Result,
			}, nil).Result,
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Consul = Pulumi.Consul;
using Example = Pulumi.Example;
using Std = Pulumi.Std;

return await Deployment.RunAsync(() => 
{
    var read_dc1_nodes = Consul.GetNodes.Invoke(new()
    {
        QueryOptions = new[]
        {
            new Consul.Inputs.GetNodesQueryOptionInputArgs
            {
                Datacenter = "dc1",
            },
        },
    });

    // Set the description to a whitespace delimited list of the node names
    var app = new Example.Index.Resource("app", new()
    {
        Description = Std.Join.Invoke(new()
        {
            Separator = " ",
            Input = Std.Formatlist.Invoke(new()
            {
                Input = "%s",
                Args = new[]
                {
                    nodeNames,
                },
            }).Result,
        }).Result,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.consul.ConsulFunctions;
import com.pulumi.consul.inputs.GetNodesArgs;
import com.pulumi.example.Resource;
import com.pulumi.example.ResourceArgs;
import com.pulumi.std.StdFunctions;
import com.pulumi.std.inputs.FormatlistArgs;
import com.pulumi.std.inputs.JoinArgs;
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 read-dc1-nodes = ConsulFunctions.getNodes(GetNodesArgs.builder()
            .queryOptions(GetNodesQueryOptionArgs.builder()
                .datacenter("dc1")
                .build())
            .build());

        // Set the description to a whitespace delimited list of the node names
        var app = new Resource("app", ResourceArgs.builder()
            .description(StdFunctions.join(JoinArgs.builder()
                .separator(" ")
                .input(StdFunctions.formatlist(FormatlistArgs.builder()
                    .input("%s")
                    .args(nodeNames)
                    .build()).result())
                .build()).result())
            .build());

    }
}

resources:
  # Set the description to a whitespace delimited list of the node names
  app:
    type: example:Resource
    properties:
      description:
        fn::invoke:
          function: std:join
          arguments:
            separator: ' '
            input:
              fn::invoke:
                function: std:formatlist
                arguments:
                  input: '%s'
                  args:
                    - ${nodeNames}
                return: result
          return: result
variables:
  read-dc1-nodes:
    fn::invoke:
      function: consul:getNodes
      arguments:
        queryOptions:
          - datacenter: dc1

Using getCatalogNodes

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 getCatalogNodes(args: GetCatalogNodesArgs, opts?: InvokeOptions): Promise<GetCatalogNodesResult>
function getCatalogNodesOutput(args: GetCatalogNodesOutputArgs, opts?: InvokeOptions): Output<GetCatalogNodesResult>

def get_catalog_nodes(query_options: Optional[Sequence[GetCatalogNodesQueryOption]] = None,
                      opts: Optional[InvokeOptions] = None) -> GetCatalogNodesResult
def get_catalog_nodes_output(query_options: Optional[pulumi.Input[Sequence[pulumi.Input[GetCatalogNodesQueryOptionArgs]]]] = None,
                      opts: Optional[InvokeOptions] = None) -> Output[GetCatalogNodesResult]

func GetCatalogNodes(ctx *Context, args *GetCatalogNodesArgs, opts ...InvokeOption) (*GetCatalogNodesResult, error)
func GetCatalogNodesOutput(ctx *Context, args *GetCatalogNodesOutputArgs, opts ...InvokeOption) GetCatalogNodesResultOutput

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

public static class GetCatalogNodes 
{
    public static Task<GetCatalogNodesResult> InvokeAsync(GetCatalogNodesArgs args, InvokeOptions? opts = null)
    public static Output<GetCatalogNodesResult> Invoke(GetCatalogNodesInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetCatalogNodesResult> getCatalogNodes(GetCatalogNodesArgs args, InvokeOptions options)
public static Output<GetCatalogNodesResult> getCatalogNodes(GetCatalogNodesArgs args, InvokeOptions options)

fn::invoke:
  function: consul:index/getCatalogNodes:getCatalogNodes
  arguments:
    # arguments dictionary

The following arguments are supported:

QueryOptions List<GetCatalogNodesQueryOption>: See below.

QueryOptions []GetCatalogNodesQueryOption: See below.

queryOptions List<GetCatalogNodesQueryOption>: See below.

queryOptions GetCatalogNodesQueryOption[]: See below.

query_options Sequence[GetCatalogNodesQueryOption]: See below.

queryOptions List<Property Map>: See below.