scaleway.mongodb.getDatabases

import * as pulumi from "@pulumi/pulumi";
import * as scaleway from "@pulumiverse/scaleway";

const main = new scaleway.mongodb.Instance("main", {
    name: "foobar",
    version: "7.0",
    nodeType: "MGDB-PLAY2-NANO",
    nodeNumber: 1,
    userName: "my_initial_user",
    password: "thiZ_is_v&ry_s3cret",
});
const db = scaleway.mongodb.getDatabasesOutput({
    instanceId: main.id,
    region: "fr-par",
});
export const databaseNames = db.apply(db => .map(database => (database.name)));

import pulumi
import pulumi_scaleway as scaleway
import pulumiverse_scaleway as scaleway

main = scaleway.mongodb.Instance("main",
    name="foobar",
    version="7.0",
    node_type="MGDB-PLAY2-NANO",
    node_number=1,
    user_name="my_initial_user",
    password="thiZ_is_v&ry_s3cret")
db = scaleway.mongodb.get_databases_output(instance_id=main.id,
    region="fr-par")
pulumi.export("databaseNames", db.apply(lambda db: [database.name for database in db.databases]))

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Scaleway = Pulumiverse.Scaleway;

return await Deployment.RunAsync(() => 
{
    var main = new Scaleway.Mongodb.Instance("main", new()
    {
        Name = "foobar",
        Version = "7.0",
        NodeType = "MGDB-PLAY2-NANO",
        NodeNumber = 1,
        UserName = "my_initial_user",
        Password = "thiZ_is_v&ry_s3cret",
    });

    var db = Scaleway.Mongodb.GetDatabases.Invoke(new()
    {
        InstanceId = main.Id,
        Region = "fr-par",
    });

    return new Dictionary<string, object?>
    {
        ["databaseNames"] = .Select(database => 
        {
            return database.Name;
        }).ToList(),
    };
});

function getDatabases(args: GetDatabasesArgs, opts?: InvokeOptions): Promise<GetDatabasesResult>
function getDatabasesOutput(args: GetDatabasesOutputArgs, opts?: InvokeOptions): Output<GetDatabasesResult>

def get_databases(instance_id: Optional[str] = None,
                  region: Optional[str] = None,
                  opts: Optional[InvokeOptions] = None) -> GetDatabasesResult
def get_databases_output(instance_id: pulumi.Input[Optional[str]] = None,
                  region: pulumi.Input[Optional[str]] = None,
                  opts: Optional[InvokeOptions] = None) -> Output[GetDatabasesResult]

func GetDatabases(ctx *Context, args *GetDatabasesArgs, opts ...InvokeOption) (*GetDatabasesResult, error)
func GetDatabasesOutput(ctx *Context, args *GetDatabasesOutputArgs, opts ...InvokeOption) GetDatabasesResultOutput

public static class GetDatabases 
{
    public static Task<GetDatabasesResult> InvokeAsync(GetDatabasesArgs args, InvokeOptions? opts = null)
    public static Output<GetDatabasesResult> Invoke(GetDatabasesInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetDatabasesResult> getDatabases(GetDatabasesArgs args, InvokeOptions options)
public static Output<GetDatabasesResult> getDatabases(GetDatabasesArgs args, InvokeOptions options)

fn::invoke:
  function: scaleway:mongodb/getDatabases:getDatabases
  arguments:
    # arguments dictionary

data "scaleway_mongodb_getdatabases" "name" {
    # arguments
}