ucloud.getUmongodbInstances

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

const example = ucloud.getUmongodbInstances({
    availabilityZone: "cn-bj2-05",
});

import pulumi
import pulumi_ucloud as ucloud

example = ucloud.get_umongodb_instances(availability_zone="cn-bj2-05")

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := ucloud.GetUmongodbInstances(ctx, &ucloud.GetUmongodbInstancesArgs{
			AvailabilityZone: pulumi.StringRef("cn-bj2-05"),
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var example = Ucloud.GetUmongodbInstances.Invoke(new()
    {
        AvailabilityZone = "cn-bj2-05",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.ucloud.UcloudFunctions;
import com.pulumi.ucloud.inputs.GetUmongodbInstancesArgs;
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 = UcloudFunctions.getUmongodbInstances(GetUmongodbInstancesArgs.builder()
            .availabilityZone("cn-bj2-05")
            .build());

    }
}

variables:
  example:
    fn::invoke:
      function: ucloud:getUmongodbInstances
      arguments:
        availabilityZone: cn-bj2-05

function getUmongodbInstances(args: GetUmongodbInstancesArgs, opts?: InvokeOptions): Promise<GetUmongodbInstancesResult>
function getUmongodbInstancesOutput(args: GetUmongodbInstancesOutputArgs, opts?: InvokeOutputOptions): Output<GetUmongodbInstancesResult>

def get_umongodb_instances(availability_zone: Optional[str] = None,
                           cluster_id: Optional[str] = None,
                           id: Optional[str] = None,
                           opts: Optional[InvokeOptions] = None) -> GetUmongodbInstancesResult
def get_umongodb_instances_output(availability_zone: pulumi.Input[Optional[str]] = None,
                           cluster_id: pulumi.Input[Optional[str]] = None,
                           id: pulumi.Input[Optional[str]] = None,
                           opts: Optional[InvokeOutputOptions] = None) -> Output[GetUmongodbInstancesResult]

func GetUmongodbInstances(ctx *Context, args *GetUmongodbInstancesArgs, opts ...InvokeOption) (*GetUmongodbInstancesResult, error)
func GetUmongodbInstancesOutput(ctx *Context, args *GetUmongodbInstancesOutputArgs, opts ...InvokeOption) GetUmongodbInstancesResultOutput

public static class GetUmongodbInstances 
{
    public static Task<GetUmongodbInstancesResult> InvokeAsync(GetUmongodbInstancesArgs args, InvokeOptions? opts = null)
    public static Output<GetUmongodbInstancesResult> Invoke(GetUmongodbInstancesInvokeArgs args, InvokeOptions? opts = null)
    public static Output<GetUmongodbInstancesResult> Invoke(GetUmongodbInstancesInvokeArgs args, InvokeOutputOptions opts)
}

public static CompletableFuture<GetUmongodbInstancesResult> getUmongodbInstances(GetUmongodbInstancesArgs args, InvokeOptions options)
public static Output<GetUmongodbInstancesResult> getUmongodbInstances(GetUmongodbInstancesArgs args, InvokeOptions options)
public static Output<GetUmongodbInstancesResult> getUmongodbInstances(GetUmongodbInstancesArgs args, InvokeOutputOptions options)

fn::invoke:
  function: ucloud:index/getUmongodbInstances:getUmongodbInstances
  arguments:
    # arguments dictionary

data "ucloud_get_umongodb_instances" "name" {
    # arguments
}