upcloud.getManagedDatabaseValkeySessions

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 Valkey Database
// Create a Managed Valkey resource
const exampleManagedDatabaseValkey = new upcloud.ManagedDatabaseValkey("example", {
    name: "example",
    title: "example",
    plan: "1x1xCPU-2GB",
    zone: "fi-hel2",
});
// Read the active sessions of the newly created service
const example = upcloud.getManagedDatabaseValkeySessionsOutput({
    service: exampleManagedDatabaseValkey.id,
});

import pulumi
import pulumi_upcloud as upcloud

# Use data source to gather a list of the active sessions for a Managed Valkey Database
# Create a Managed Valkey resource
example_managed_database_valkey = upcloud.ManagedDatabaseValkey("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_valkey_sessions_output(service=example_managed_database_valkey.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 Valkey Database
		// Create a Managed Valkey resource
		exampleManagedDatabaseValkey, err := upcloud.NewManagedDatabaseValkey(ctx, "example", &upcloud.ManagedDatabaseValkeyArgs{
			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.GetManagedDatabaseValkeySessionsOutput(ctx, upcloud.GetManagedDatabaseValkeySessionsOutputArgs{
			Service: exampleManagedDatabaseValkey.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 Valkey Database
    // Create a Managed Valkey resource
    var exampleManagedDatabaseValkey = new UpCloud.ManagedDatabaseValkey("example", new()
    {
        Name = "example",
        Title = "example",
        Plan = "1x1xCPU-2GB",
        Zone = "fi-hel2",
    });

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

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.upcloud.ManagedDatabaseValkey;
import com.pulumi.upcloud.ManagedDatabaseValkeyArgs;
import com.pulumi.upcloud.UpcloudFunctions;
import com.pulumi.upcloud.inputs.GetManagedDatabaseValkeySessionsArgs;
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 Valkey Database
        // Create a Managed Valkey resource
        var exampleManagedDatabaseValkey = new ManagedDatabaseValkey("exampleManagedDatabaseValkey", ManagedDatabaseValkeyArgs.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.getManagedDatabaseValkeySessions(GetManagedDatabaseValkeySessionsArgs.builder()
            .service(exampleManagedDatabaseValkey.id())
            .build());

    }
}

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

  # Create a Managed Valkey resource
  exampleManagedDatabaseValkey:
    type: upcloud:ManagedDatabaseValkey
    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:getManagedDatabaseValkeySessions
      arguments:
        service: ${exampleManagedDatabaseValkey.id}

function getManagedDatabaseValkeySessions(args: GetManagedDatabaseValkeySessionsArgs, opts?: InvokeOptions): Promise<GetManagedDatabaseValkeySessionsResult>
function getManagedDatabaseValkeySessionsOutput(args: GetManagedDatabaseValkeySessionsOutputArgs, opts?: InvokeOptions): Output<GetManagedDatabaseValkeySessionsResult>

def get_managed_database_valkey_sessions(limit: Optional[int] = None,
                                         offset: Optional[int] = None,
                                         order: Optional[str] = None,
                                         service: Optional[str] = None,
                                         sessions: Optional[Sequence[GetManagedDatabaseValkeySessionsSession]] = None,
                                         opts: Optional[InvokeOptions] = None) -> GetManagedDatabaseValkeySessionsResult
def get_managed_database_valkey_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[GetManagedDatabaseValkeySessionsSessionArgs]]]] = None,
                                         opts: Optional[InvokeOptions] = None) -> Output[GetManagedDatabaseValkeySessionsResult]

func GetManagedDatabaseValkeySessions(ctx *Context, args *GetManagedDatabaseValkeySessionsArgs, opts ...InvokeOption) (*GetManagedDatabaseValkeySessionsResult, error)
func GetManagedDatabaseValkeySessionsOutput(ctx *Context, args *GetManagedDatabaseValkeySessionsOutputArgs, opts ...InvokeOption) GetManagedDatabaseValkeySessionsResultOutput

public static class GetManagedDatabaseValkeySessions 
{
    public static Task<GetManagedDatabaseValkeySessionsResult> InvokeAsync(GetManagedDatabaseValkeySessionsArgs args, InvokeOptions? opts = null)
    public static Output<GetManagedDatabaseValkeySessionsResult> Invoke(GetManagedDatabaseValkeySessionsInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetManagedDatabaseValkeySessionsResult> getManagedDatabaseValkeySessions(GetManagedDatabaseValkeySessionsArgs args, InvokeOptions options)
public static Output<GetManagedDatabaseValkeySessionsResult> getManagedDatabaseValkeySessions(GetManagedDatabaseValkeySessionsArgs args, InvokeOptions options)

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