redpanda.getServerlessCluster

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

const example = redpanda.getServerlessCluster({
    id: "serverless_cluster_id",
});

import pulumi
import pulumi_redpanda as redpanda

example = redpanda.get_serverless_cluster(id="serverless_cluster_id")

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := redpanda.LookupServerlessCluster(ctx, &redpanda.LookupServerlessClusterArgs{
			Id: "serverless_cluster_id",
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var example = Redpanda.GetServerlessCluster.Invoke(new()
    {
        Id = "serverless_cluster_id",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.redpanda.RedpandaFunctions;
import com.pulumi.redpanda.inputs.GetServerlessClusterArgs;
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 example = RedpandaFunctions.getServerlessCluster(GetServerlessClusterArgs.builder()
            .id("serverless_cluster_id")
            .build());

    }
}

variables:
  example:
    fn::invoke:
      function: redpanda:getServerlessCluster
      arguments:
        id: serverless_cluster_id

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

const testResourceGroup = new redpanda.ResourceGroup("testResourceGroup", {});
const config = new pulumi.Config();
const region = config.get("region") || "pro-us-east-1";
const testServerlessCluster = new redpanda.ServerlessCluster("testServerlessCluster", {
    resourceGroupId: testResourceGroup.id,
    serverlessRegion: region,
});
const resourceGroupName = config.get("resourceGroupName") || "testgroup";
const clusterName = config.get("clusterName") || "testname";

import pulumi
import pulumi_redpanda as redpanda

test_resource_group = redpanda.ResourceGroup("testResourceGroup")
config = pulumi.Config()
region = config.get("region")
if region is None:
    region = "pro-us-east-1"
test_serverless_cluster = redpanda.ServerlessCluster("testServerlessCluster",
    resource_group_id=test_resource_group.id,
    serverless_region=region)
resource_group_name = config.get("resourceGroupName")
if resource_group_name is None:
    resource_group_name = "testgroup"
cluster_name = config.get("clusterName")
if cluster_name is None:
    cluster_name = "testname"

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		testResourceGroup, err := redpanda.NewResourceGroup(ctx, "testResourceGroup", nil)
		if err != nil {
			return err
		}
		cfg := config.New(ctx, "")
		region := "pro-us-east-1"
		if param := cfg.Get("region"); param != "" {
			region = param
		}
		_, err = redpanda.NewServerlessCluster(ctx, "testServerlessCluster", &redpanda.ServerlessClusterArgs{
			ResourceGroupId:  testResourceGroup.ID(),
			ServerlessRegion: pulumi.String(region),
		})
		if err != nil {
			return err
		}
		resourceGroupName := "testgroup"
		if param := cfg.Get("resourceGroupName"); param != "" {
			resourceGroupName = param
		}
		clusterName := "testname"
		if param := cfg.Get("clusterName"); param != "" {
			clusterName = param
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var testResourceGroup = new Redpanda.ResourceGroup("testResourceGroup");

    var config = new Config();
    var region = config.Get("region") ?? "pro-us-east-1";
    var testServerlessCluster = new Redpanda.ServerlessCluster("testServerlessCluster", new()
    {
        ResourceGroupId = testResourceGroup.Id,
        ServerlessRegion = region,
    });

    var resourceGroupName = config.Get("resourceGroupName") ?? "testgroup";
    var clusterName = config.Get("clusterName") ?? "testname";
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.redpanda.ResourceGroup;
import com.pulumi.redpanda.ServerlessCluster;
import com.pulumi.redpanda.ServerlessClusterArgs;
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 config = ctx.config();
        var testResourceGroup = new ResourceGroup("testResourceGroup");

        final var region = config.get("region").orElse("pro-us-east-1");
        var testServerlessCluster = new ServerlessCluster("testServerlessCluster", ServerlessClusterArgs.builder()
            .resourceGroupId(testResourceGroup.id())
            .serverlessRegion(region)
            .build());

        final var resourceGroupName = config.get("resourceGroupName").orElse("testgroup");
        final var clusterName = config.get("clusterName").orElse("testname");
    }
}

configuration:
  resourceGroupName:
    type: string
    default: testgroup
  clusterName:
    type: string
    default: testname
  region:
    type: string
    default: pro-us-east-1
resources:
  testResourceGroup:
    type: redpanda:ResourceGroup
  testServerlessCluster:
    type: redpanda:ServerlessCluster
    properties:
      resourceGroupId: ${testResourceGroup.id}
      serverlessRegion: ${region}

function getServerlessCluster(args: GetServerlessClusterArgs, opts?: InvokeOptions): Promise<GetServerlessClusterResult>
function getServerlessClusterOutput(args: GetServerlessClusterOutputArgs, opts?: InvokeOptions): Output<GetServerlessClusterResult>

def get_serverless_cluster(id: Optional[str] = None,
                           opts: Optional[InvokeOptions] = None) -> GetServerlessClusterResult
def get_serverless_cluster_output(id: Optional[pulumi.Input[str]] = None,
                           opts: Optional[InvokeOptions] = None) -> Output[GetServerlessClusterResult]

func LookupServerlessCluster(ctx *Context, args *LookupServerlessClusterArgs, opts ...InvokeOption) (*LookupServerlessClusterResult, error)
func LookupServerlessClusterOutput(ctx *Context, args *LookupServerlessClusterOutputArgs, opts ...InvokeOption) LookupServerlessClusterResultOutput

public static class GetServerlessCluster 
{
    public static Task<GetServerlessClusterResult> InvokeAsync(GetServerlessClusterArgs args, InvokeOptions? opts = null)
    public static Output<GetServerlessClusterResult> Invoke(GetServerlessClusterInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetServerlessClusterResult> getServerlessCluster(GetServerlessClusterArgs args, InvokeOptions options)
public static Output<GetServerlessClusterResult> getServerlessCluster(GetServerlessClusterArgs args, InvokeOptions options)

fn::invoke:
  function: redpanda:index/getServerlessCluster:getServerlessCluster
  arguments:
    # arguments dictionary