upcloud.getManagedDatabaseMysqlSessions

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 MySQL Database
// Create a Managed MySQL resource
const exampleManagedDatabaseMysql = new upcloud.ManagedDatabaseMysql("example", {
    name: "mysql-example1",
    title: "mysql-example1",
    plan: "1x1xCPU-2GB-25GB",
    zone: "fi-hel1",
});
// Read the active sessions of the newly created service
const example = upcloud.getManagedDatabaseMysqlSessionsOutput({
    service: exampleManagedDatabaseMysql.id,
});

import pulumi
import pulumi_upcloud as upcloud

# Use data source to gather a list of the active sessions for a Managed MySQL Database
# Create a Managed MySQL resource
example_managed_database_mysql = upcloud.ManagedDatabaseMysql("example",
    name="mysql-example1",
    title="mysql-example1",
    plan="1x1xCPU-2GB-25GB",
    zone="fi-hel1")
# Read the active sessions of the newly created service
example = upcloud.get_managed_database_mysql_sessions_output(service=example_managed_database_mysql.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 MySQL Database
		// Create a Managed MySQL resource
		exampleManagedDatabaseMysql, err := upcloud.NewManagedDatabaseMysql(ctx, "example", &upcloud.ManagedDatabaseMysqlArgs{
			Name:  pulumi.String("mysql-example1"),
			Title: pulumi.String("mysql-example1"),
			Plan:  pulumi.String("1x1xCPU-2GB-25GB"),
			Zone:  pulumi.String("fi-hel1"),
		})
		if err != nil {
			return err
		}
		// Read the active sessions of the newly created service
		_ = upcloud.GetManagedDatabaseMysqlSessionsOutput(ctx, upcloud.GetManagedDatabaseMysqlSessionsOutputArgs{
			Service: exampleManagedDatabaseMysql.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 MySQL Database
    // Create a Managed MySQL resource
    var exampleManagedDatabaseMysql = new UpCloud.ManagedDatabaseMysql("example", new()
    {
        Name = "mysql-example1",
        Title = "mysql-example1",
        Plan = "1x1xCPU-2GB-25GB",
        Zone = "fi-hel1",
    });

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

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.upcloud.ManagedDatabaseMysql;
import com.pulumi.upcloud.ManagedDatabaseMysqlArgs;
import com.pulumi.upcloud.UpcloudFunctions;
import com.pulumi.upcloud.inputs.GetManagedDatabaseMysqlSessionsArgs;
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 MySQL Database
        // Create a Managed MySQL resource
        var exampleManagedDatabaseMysql = new ManagedDatabaseMysql("exampleManagedDatabaseMysql", ManagedDatabaseMysqlArgs.builder()
            .name("mysql-example1")
            .title("mysql-example1")
            .plan("1x1xCPU-2GB-25GB")
            .zone("fi-hel1")
            .build());

        // Read the active sessions of the newly created service
        final var example = UpcloudFunctions.getManagedDatabaseMysqlSessions(GetManagedDatabaseMysqlSessionsArgs.builder()
            .service(exampleManagedDatabaseMysql.id())
            .build());

    }
}

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

  # Create a Managed MySQL resource
  exampleManagedDatabaseMysql:
    type: upcloud:ManagedDatabaseMysql
    name: example
    properties:
      name: mysql-example1
      title: mysql-example1
      plan: 1x1xCPU-2GB-25GB
      zone: fi-hel1
variables:
  # Read the active sessions of the newly created service
  example:
    fn::invoke:
      function: upcloud:getManagedDatabaseMysqlSessions
      arguments:
        service: ${exampleManagedDatabaseMysql.id}

function getManagedDatabaseMysqlSessions(args: GetManagedDatabaseMysqlSessionsArgs, opts?: InvokeOptions): Promise<GetManagedDatabaseMysqlSessionsResult>
function getManagedDatabaseMysqlSessionsOutput(args: GetManagedDatabaseMysqlSessionsOutputArgs, opts?: InvokeOptions): Output<GetManagedDatabaseMysqlSessionsResult>

def get_managed_database_mysql_sessions(limit: Optional[int] = None,
                                        offset: Optional[int] = None,
                                        order: Optional[str] = None,
                                        service: Optional[str] = None,
                                        sessions: Optional[Sequence[GetManagedDatabaseMysqlSessionsSession]] = None,
                                        opts: Optional[InvokeOptions] = None) -> GetManagedDatabaseMysqlSessionsResult
def get_managed_database_mysql_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[GetManagedDatabaseMysqlSessionsSessionArgs]]]] = None,
                                        opts: Optional[InvokeOptions] = None) -> Output[GetManagedDatabaseMysqlSessionsResult]

func GetManagedDatabaseMysqlSessions(ctx *Context, args *GetManagedDatabaseMysqlSessionsArgs, opts ...InvokeOption) (*GetManagedDatabaseMysqlSessionsResult, error)
func GetManagedDatabaseMysqlSessionsOutput(ctx *Context, args *GetManagedDatabaseMysqlSessionsOutputArgs, opts ...InvokeOption) GetManagedDatabaseMysqlSessionsResultOutput

public static class GetManagedDatabaseMysqlSessions 
{
    public static Task<GetManagedDatabaseMysqlSessionsResult> InvokeAsync(GetManagedDatabaseMysqlSessionsArgs args, InvokeOptions? opts = null)
    public static Output<GetManagedDatabaseMysqlSessionsResult> Invoke(GetManagedDatabaseMysqlSessionsInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetManagedDatabaseMysqlSessionsResult> getManagedDatabaseMysqlSessions(GetManagedDatabaseMysqlSessionsArgs args, InvokeOptions options)
public static Output<GetManagedDatabaseMysqlSessionsResult> getManagedDatabaseMysqlSessions(GetManagedDatabaseMysqlSessionsArgs args, InvokeOptions options)

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