getPlacementGroups

Linode v6.6.0, Sep 15 26

Viewing docs for Linode v6.6.0
published on Tuesday, Sep 15, 2026 by Pulumi

Schema (JSON)

pulumi/pulumi-linode

Viewing docs for Linode v6.6.0
published on Tuesday, Sep 15, 2026 by Pulumi

Schema (JSON)

pulumi/pulumi-linode

Example Usage

The following example shows how one might use this data source to list Placement Groups.

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

export = async () => {
    const all = await linode.getPlacementGroups({});
    const filtered = await linode.getPlacementGroups({
        filters: [{
            name: "label",
            values: ["my-label"],
        }],
    });
    return {
        "all-pgs": all.placementGroups,
        "filtered-pgs": filtered.placementGroups,
    };
}

import pulumi
import pulumi_linode as linode

all = linode.get_placement_groups()
filtered = linode.get_placement_groups(filters=[{
    "name": "label",
    "values": ["my-label"],
}])
pulumi.export("all-pgs", all.placement_groups)
pulumi.export("filtered-pgs", filtered.placement_groups)

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 {
		all, err := linode.GetPlacementGroups(ctx, &linode.GetPlacementGroupsArgs{}, nil)
		if err != nil {
			return err
		}
		filtered, err := linode.GetPlacementGroups(ctx, &linode.GetPlacementGroupsArgs{
			Filters: []linode.GetPlacementGroupsFilter{
				{
					Name: "label",
					Values: []string{
						"my-label",
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("all-pgs", all.PlacementGroups)
		ctx.Export("filtered-pgs", filtered.PlacementGroups)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var all = Linode.GetPlacementGroups.Invoke();

    var filtered = Linode.GetPlacementGroups.Invoke(new()
    {
        Filters = new[]
        {
            new Linode.Inputs.GetPlacementGroupsFilterInputArgs
            {
                Name = "label",
                Values = new[]
                {
                    "my-label",
                },
            },
        },
    });

    return new Dictionary<string, object?>
    {
        ["all-pgs"] = all.Apply(getPlacementGroupsResult => getPlacementGroupsResult.PlacementGroups),
        ["filtered-pgs"] = filtered.Apply(getPlacementGroupsResult => getPlacementGroupsResult.PlacementGroups),
    };
});

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.GetPlacementGroupsArgs;
import com.pulumi.linode.inputs.GetPlacementGroupsFilterArgs;
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 all = LinodeFunctions.getPlacementGroups(GetPlacementGroupsArgs.builder()
            .build());

        final var filtered = LinodeFunctions.getPlacementGroups(GetPlacementGroupsArgs.builder()
            .filters(GetPlacementGroupsFilterArgs.builder()
                .name("label")
                .values("my-label")
                .build())
            .build());

        ctx.export("all-pgs", all.placementGroups());
        ctx.export("filtered-pgs", filtered.placementGroups());
    }
}

variables:
  all:
    fn::invoke:
      function: linode:getPlacementGroups
      arguments: {}
  filtered:
    fn::invoke:
      function: linode:getPlacementGroups
      arguments:
        filters:
          - name: label
            values:
              - my-label
outputs:
  all-pgs: ${all.placementGroups}
  filtered-pgs: ${filtered.placementGroups}

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

data "linode_getplacementgroups" "all" {
}
data "linode_getplacementgroups" "filtered" {
  filters {
    name   = "label"
    values = ["my-label"]
  }
}

output "all-pgs" {
  value = data.linode_getplacementgroups.all.placement_groups
}
output "filtered-pgs" {
  value = data.linode_getplacementgroups.filtered.placement_groups
}

Filterable Fields

id
label
region
placementGroupType
placementGroupPolicy
isCompliant

Using getPlacementGroups

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 getPlacementGroups(args: GetPlacementGroupsArgs, opts?: InvokeOptions): Promise<GetPlacementGroupsResult>
function getPlacementGroupsOutput(args: GetPlacementGroupsOutputArgs, opts?: InvokeOutputOptions): Output<GetPlacementGroupsResult>

def get_placement_groups(filters: Optional[Sequence[GetPlacementGroupsFilter]] = None,
                         order: Optional[str] = None,
                         order_by: Optional[str] = None,
                         opts: Optional[InvokeOptions] = None) -> GetPlacementGroupsResult
def get_placement_groups_output(filters: pulumi.Input[Optional[Sequence[pulumi.Input[GetPlacementGroupsFilterArgs]]]] = None,
                         order: pulumi.Input[Optional[str]] = None,
                         order_by: pulumi.Input[Optional[str]] = None,
                         opts: Optional[InvokeOutputOptions] = None) -> Output[GetPlacementGroupsResult]

func GetPlacementGroups(ctx *Context, args *GetPlacementGroupsArgs, opts ...InvokeOption) (*GetPlacementGroupsResult, error)
func GetPlacementGroupsOutput(ctx *Context, args *GetPlacementGroupsOutputArgs, opts ...InvokeOption) GetPlacementGroupsResultOutput

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

public static class GetPlacementGroups 
{
    public static Task<GetPlacementGroupsResult> InvokeAsync(GetPlacementGroupsArgs args, InvokeOptions? opts = null)
    public static Output<GetPlacementGroupsResult> Invoke(GetPlacementGroupsInvokeArgs args, InvokeOptions? opts = null)
    public static Output<GetPlacementGroupsResult> Invoke(GetPlacementGroupsInvokeArgs args, InvokeOutputOptions opts)
}

public static CompletableFuture<GetPlacementGroupsResult> getPlacementGroups(GetPlacementGroupsArgs args, InvokeOptions options)
public static Output<GetPlacementGroupsResult> getPlacementGroups(GetPlacementGroupsArgs args, InvokeOptions options)
public static Output<GetPlacementGroupsResult> getPlacementGroups(GetPlacementGroupsArgs args, InvokeOutputOptions options)

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

data "linode_get_placement_groups" "name" {
    # arguments
}

The following arguments are supported:

Filters List<GetPlacementGroupsFilter>
Order string
OrderBy string

Filters []GetPlacementGroupsFilter
Order string
OrderBy string

filters list(object)
order string
order_by string

filters List<GetPlacementGroupsFilter>
order String
orderBy String

filters GetPlacementGroupsFilter[]
order string
orderBy string

filters Sequence[GetPlacementGroupsFilter]
order str
order_by str

filters List<Property Map>
order String
orderBy String