ibm.getTgRedundancyGroups

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

// List all redundancy groups
const all = ibm.getTgRedundancyGroups({});
// Filter by name
const named = ibm.getTgRedundancyGroups({
    name: "my-redundancy-group",
});

import pulumi
import pulumi_ibm as ibm

# List all redundancy groups
all = ibm.get_tg_redundancy_groups()
# Filter by name
named = ibm.get_tg_redundancy_groups(name="my-redundancy-group")

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// List all redundancy groups
		_, err := ibm.GetTgRedundancyGroups(ctx, &ibm.GetTgRedundancyGroupsArgs{}, nil)
		if err != nil {
			return err
		}
		// Filter by name
		_, err = ibm.GetTgRedundancyGroups(ctx, &ibm.GetTgRedundancyGroupsArgs{
			Name: pulumi.StringRef("my-redundancy-group"),
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    // List all redundancy groups
    var all = Ibm.GetTgRedundancyGroups.Invoke();

    // Filter by name
    var named = Ibm.GetTgRedundancyGroups.Invoke(new()
    {
        Name = "my-redundancy-group",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.ibm.IbmFunctions;
import com.pulumi.ibm.inputs.GetTgRedundancyGroupsArgs;
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) {
        // List all redundancy groups
        final var all = IbmFunctions.getTgRedundancyGroups(GetTgRedundancyGroupsArgs.builder()
            .build());

        // Filter by name
        final var named = IbmFunctions.getTgRedundancyGroups(GetTgRedundancyGroupsArgs.builder()
            .name("my-redundancy-group")
            .build());

    }
}

variables:
  # List all redundancy groups
  all:
    fn::invoke:
      function: ibm:getTgRedundancyGroups
      arguments: {}
  # Filter by name
  named:
    fn::invoke:
      function: ibm:getTgRedundancyGroups
      arguments:
        name: my-redundancy-group

function getTgRedundancyGroups(args: GetTgRedundancyGroupsArgs, opts?: InvokeOptions): Promise<GetTgRedundancyGroupsResult>
function getTgRedundancyGroupsOutput(args: GetTgRedundancyGroupsOutputArgs, opts?: InvokeOutputOptions): Output<GetTgRedundancyGroupsResult>

def get_tg_redundancy_groups(id: Optional[str] = None,
                             name: Optional[str] = None,
                             opts: Optional[InvokeOptions] = None) -> GetTgRedundancyGroupsResult
def get_tg_redundancy_groups_output(id: pulumi.Input[Optional[str]] = None,
                             name: pulumi.Input[Optional[str]] = None,
                             opts: Optional[InvokeOutputOptions] = None) -> Output[GetTgRedundancyGroupsResult]

func GetTgRedundancyGroups(ctx *Context, args *GetTgRedundancyGroupsArgs, opts ...InvokeOption) (*GetTgRedundancyGroupsResult, error)
func GetTgRedundancyGroupsOutput(ctx *Context, args *GetTgRedundancyGroupsOutputArgs, opts ...InvokeOption) GetTgRedundancyGroupsResultOutput

public static class GetTgRedundancyGroups 
{
    public static Task<GetTgRedundancyGroupsResult> InvokeAsync(GetTgRedundancyGroupsArgs args, InvokeOptions? opts = null)
    public static Output<GetTgRedundancyGroupsResult> Invoke(GetTgRedundancyGroupsInvokeArgs args, InvokeOptions? opts = null)
    public static Output<GetTgRedundancyGroupsResult> Invoke(GetTgRedundancyGroupsInvokeArgs args, InvokeOutputOptions opts)
}

public static CompletableFuture<GetTgRedundancyGroupsResult> getTgRedundancyGroups(GetTgRedundancyGroupsArgs args, InvokeOptions options)
public static Output<GetTgRedundancyGroupsResult> getTgRedundancyGroups(GetTgRedundancyGroupsArgs args, InvokeOptions options)
public static Output<GetTgRedundancyGroupsResult> getTgRedundancyGroups(GetTgRedundancyGroupsArgs args, InvokeOutputOptions options)

fn::invoke:
  function: ibm:index/getTgRedundancyGroups:getTgRedundancyGroups
  arguments:
    # arguments dictionary

data "ibm_get_tg_redundancy_groups" "name" {
    # arguments
}