upcloud.getManagedDatabaseRedisSessions

import * as pulumi from "@pulumi/pulumi";
import * as upcloud from "@pulumi/upcloud";
import * as upcloud from "@upcloud/pulumi-upcloud";

// Use data source to gather a list of the active sessions for a Managed Redis Database
// Create a Managed Redis resource
const exampleManagedDatabaseRedis = new upcloud.ManagedDatabaseRedis("example", {
    name: "example",
    title: "example",
    plan: "1x1xCPU-2GB",
    zone: "fi-hel2",
});
// Read the active sessions of the newly created service
const example = upcloud.getManagedDatabaseRedisSessionsOutput({
    service: exampleManagedDatabaseRedis.id,
});

import pulumi
import pulumi_upcloud as upcloud

# Use data source to gather a list of the active sessions for a Managed Redis Database
# Create a Managed Redis resource
example_managed_database_redis = upcloud.ManagedDatabaseRedis("example",
    name="example",
    title="example",
    plan="1x1xCPU-2GB",
    zone="fi-hel2")
# Read the active sessions of the newly created service
example = upcloud.get_managed_database_redis_sessions_output(service=example_managed_database_redis.id)

package main

import (
	"github.com/UpCloudLtd/pulumi-upcloud/sdk/go/upcloud"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Use data source to gather a list of the active sessions for a Managed Redis Database
		// Create a Managed Redis resource
		exampleManagedDatabaseRedis, err := upcloud.NewManagedDatabaseRedis(ctx, "example", &upcloud.ManagedDatabaseRedisArgs{
			Name:  pulumi.String("example"),
			Title: pulumi.String("example"),
			Plan:  pulumi.String("1x1xCPU-2GB"),
			Zone:  pulumi.String("fi-hel2"),
		})
		if err != nil {
			return err
		}
		// Read the active sessions of the newly created service
		_ = upcloud.GetManagedDatabaseRedisSessionsOutput(ctx, upcloud.GetManagedDatabaseRedisSessionsOutputArgs{
			Service: exampleManagedDatabaseRedis.ID(),
		}, nil)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    // Use data source to gather a list of the active sessions for a Managed Redis Database
    // Create a Managed Redis resource
    var exampleManagedDatabaseRedis = new UpCloud.ManagedDatabaseRedis("example", new()
    {
        Name = "example",
        Title = "example",
        Plan = "1x1xCPU-2GB",
        Zone = "fi-hel2",
    });

    // Read the active sessions of the newly created service
    var example = UpCloud.GetManagedDatabaseRedisSessions.Invoke(new()
    {
        Service = exampleManagedDatabaseRedis.Id,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.upcloud.ManagedDatabaseRedis;
import com.pulumi.upcloud.ManagedDatabaseRedisArgs;
import com.pulumi.upcloud.UpcloudFunctions;
import com.pulumi.upcloud.inputs.GetManagedDatabaseRedisSessionsArgs;
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) {
        // Use data source to gather a list of the active sessions for a Managed Redis Database
        // Create a Managed Redis resource
        var exampleManagedDatabaseRedis = new ManagedDatabaseRedis("exampleManagedDatabaseRedis", ManagedDatabaseRedisArgs.builder()
            .name("example")
            .title("example")
            .plan("1x1xCPU-2GB")
            .zone("fi-hel2")
            .build());

        // Read the active sessions of the newly created service
        final var example = UpcloudFunctions.getManagedDatabaseRedisSessions(GetManagedDatabaseRedisSessionsArgs.builder()
            .service(exampleManagedDatabaseRedis.id())
            .build());

    }
}

resources:
  # Use data source to gather a list of the active sessions for a Managed Redis Database

  # Create a Managed Redis resource
  exampleManagedDatabaseRedis:
    type: upcloud:ManagedDatabaseRedis
    name: example
    properties:
      name: example
      title: example
      plan: 1x1xCPU-2GB
      zone: fi-hel2
variables:
  # Read the active sessions of the newly created service
  example:
    fn::invoke:
      function: upcloud:getManagedDatabaseRedisSessions
      arguments:
        service: ${exampleManagedDatabaseRedis.id}

function getManagedDatabaseRedisSessions(args: GetManagedDatabaseRedisSessionsArgs, opts?: InvokeOptions): Promise<GetManagedDatabaseRedisSessionsResult>
function getManagedDatabaseRedisSessionsOutput(args: GetManagedDatabaseRedisSessionsOutputArgs, opts?: InvokeOptions): Output<GetManagedDatabaseRedisSessionsResult>

def get_managed_database_redis_sessions(limit: Optional[int] = None,
                                        offset: Optional[int] = None,
                                        order: Optional[str] = None,
                                        service: Optional[str] = None,
                                        sessions: Optional[Sequence[GetManagedDatabaseRedisSessionsSession]] = None,
                                        opts: Optional[InvokeOptions] = None) -> GetManagedDatabaseRedisSessionsResult
def get_managed_database_redis_sessions_output(limit: Optional[pulumi.Input[int]] = None,
                                        offset: Optional[pulumi.Input[int]] = None,
                                        order: Optional[pulumi.Input[str]] = None,
                                        service: Optional[pulumi.Input[str]] = None,
                                        sessions: Optional[pulumi.Input[Sequence[pulumi.Input[GetManagedDatabaseRedisSessionsSessionArgs]]]] = None,
                                        opts: Optional[InvokeOptions] = None) -> Output[GetManagedDatabaseRedisSessionsResult]

func GetManagedDatabaseRedisSessions(ctx *Context, args *GetManagedDatabaseRedisSessionsArgs, opts ...InvokeOption) (*GetManagedDatabaseRedisSessionsResult, error)
func GetManagedDatabaseRedisSessionsOutput(ctx *Context, args *GetManagedDatabaseRedisSessionsOutputArgs, opts ...InvokeOption) GetManagedDatabaseRedisSessionsResultOutput

public static class GetManagedDatabaseRedisSessions 
{
    public static Task<GetManagedDatabaseRedisSessionsResult> InvokeAsync(GetManagedDatabaseRedisSessionsArgs args, InvokeOptions? opts = null)
    public static Output<GetManagedDatabaseRedisSessionsResult> Invoke(GetManagedDatabaseRedisSessionsInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetManagedDatabaseRedisSessionsResult> getManagedDatabaseRedisSessions(GetManagedDatabaseRedisSessionsArgs args, InvokeOptions options)
public static Output<GetManagedDatabaseRedisSessionsResult> getManagedDatabaseRedisSessions(GetManagedDatabaseRedisSessionsArgs args, InvokeOptions options)

fn::invoke:
  function: upcloud:index/getManagedDatabaseRedisSessions:getManagedDatabaseRedisSessions
  arguments:
    # arguments dictionary