alicloud.simpleapplicationserver.getServerDisks

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

const ids = alicloud.simpleapplicationserver.getServerDisks({
    ids: ["example_id"],
});
export const simpleApplicationServerDiskId1 = ids.then(ids => ids.disks?.[0]?.id);
const nameRegex = alicloud.simpleapplicationserver.getServerDisks({
    nameRegex: "^my-Disk",
});
export const simpleApplicationServerDiskId2 = nameRegex.then(nameRegex => nameRegex.disks?.[0]?.id);
const status = alicloud.simpleapplicationserver.getServerDisks({
    status: "In_use",
});
export const simpleApplicationServerDiskId3 = status.then(status => status.disks?.[0]?.id);
const instanceId = alicloud.simpleapplicationserver.getServerDisks({
    instanceId: "example_value",
});
export const simpleApplicationServerDiskId4 = instanceId.then(instanceId => instanceId.disks?.[0]?.id);
const diskType = alicloud.simpleapplicationserver.getServerDisks({
    diskType: "System",
});
export const simpleApplicationServerDiskId5 = diskType.then(diskType => diskType.disks?.[0]?.id);

import pulumi
import pulumi_alicloud as alicloud

ids = alicloud.simpleapplicationserver.get_server_disks(ids=["example_id"])
pulumi.export("simpleApplicationServerDiskId1", ids.disks[0].id)
name_regex = alicloud.simpleapplicationserver.get_server_disks(name_regex="^my-Disk")
pulumi.export("simpleApplicationServerDiskId2", name_regex.disks[0].id)
status = alicloud.simpleapplicationserver.get_server_disks(status="In_use")
pulumi.export("simpleApplicationServerDiskId3", status.disks[0].id)
instance_id = alicloud.simpleapplicationserver.get_server_disks(instance_id="example_value")
pulumi.export("simpleApplicationServerDiskId4", instance_id.disks[0].id)
disk_type = alicloud.simpleapplicationserver.get_server_disks(disk_type="System")
pulumi.export("simpleApplicationServerDiskId5", disk_type.disks[0].id)

package main

import (
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/simpleapplicationserver"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		ids, err := simpleapplicationserver.GetServerDisks(ctx, &simpleapplicationserver.GetServerDisksArgs{
			Ids: []string{
				"example_id",
			},
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("simpleApplicationServerDiskId1", ids.Disks[0].Id)
		nameRegex, err := simpleapplicationserver.GetServerDisks(ctx, &simpleapplicationserver.GetServerDisksArgs{
			NameRegex: pulumi.StringRef("^my-Disk"),
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("simpleApplicationServerDiskId2", nameRegex.Disks[0].Id)
		status, err := simpleapplicationserver.GetServerDisks(ctx, &simpleapplicationserver.GetServerDisksArgs{
			Status: pulumi.StringRef("In_use"),
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("simpleApplicationServerDiskId3", status.Disks[0].Id)
		instanceId, err := simpleapplicationserver.GetServerDisks(ctx, &simpleapplicationserver.GetServerDisksArgs{
			InstanceId: pulumi.StringRef("example_value"),
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("simpleApplicationServerDiskId4", instanceId.Disks[0].Id)
		diskType, err := simpleapplicationserver.GetServerDisks(ctx, &simpleapplicationserver.GetServerDisksArgs{
			DiskType: pulumi.StringRef("System"),
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("simpleApplicationServerDiskId5", diskType.Disks[0].Id)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var ids = AliCloud.SimpleApplicationServer.GetServerDisks.Invoke(new()
    {
        Ids = new[]
        {
            "example_id",
        },
    });

    var nameRegex = AliCloud.SimpleApplicationServer.GetServerDisks.Invoke(new()
    {
        NameRegex = "^my-Disk",
    });

    var status = AliCloud.SimpleApplicationServer.GetServerDisks.Invoke(new()
    {
        Status = "In_use",
    });

    var instanceId = AliCloud.SimpleApplicationServer.GetServerDisks.Invoke(new()
    {
        InstanceId = "example_value",
    });

    var diskType = AliCloud.SimpleApplicationServer.GetServerDisks.Invoke(new()
    {
        DiskType = "System",
    });

    return new Dictionary<string, object?>
    {
        ["simpleApplicationServerDiskId1"] = ids.Apply(getServerDisksResult => getServerDisksResult.Disks[0]?.Id),
        ["simpleApplicationServerDiskId2"] = nameRegex.Apply(getServerDisksResult => getServerDisksResult.Disks[0]?.Id),
        ["simpleApplicationServerDiskId3"] = status.Apply(getServerDisksResult => getServerDisksResult.Disks[0]?.Id),
        ["simpleApplicationServerDiskId4"] = instanceId.Apply(getServerDisksResult => getServerDisksResult.Disks[0]?.Id),
        ["simpleApplicationServerDiskId5"] = diskType.Apply(getServerDisksResult => getServerDisksResult.Disks[0]?.Id),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.alicloud.simpleapplicationserver.SimpleapplicationserverFunctions;
import com.pulumi.alicloud.simpleapplicationserver.inputs.GetServerDisksArgs;
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 ids = SimpleapplicationserverFunctions.getServerDisks(GetServerDisksArgs.builder()
            .ids("example_id")
            .build());

        ctx.export("simpleApplicationServerDiskId1", ids.applyValue(getServerDisksResult -> getServerDisksResult.disks()[0].id()));
        final var nameRegex = SimpleapplicationserverFunctions.getServerDisks(GetServerDisksArgs.builder()
            .nameRegex("^my-Disk")
            .build());

        ctx.export("simpleApplicationServerDiskId2", nameRegex.applyValue(getServerDisksResult -> getServerDisksResult.disks()[0].id()));
        final var status = SimpleapplicationserverFunctions.getServerDisks(GetServerDisksArgs.builder()
            .status("In_use")
            .build());

        ctx.export("simpleApplicationServerDiskId3", status.applyValue(getServerDisksResult -> getServerDisksResult.disks()[0].id()));
        final var instanceId = SimpleapplicationserverFunctions.getServerDisks(GetServerDisksArgs.builder()
            .instanceId("example_value")
            .build());

        ctx.export("simpleApplicationServerDiskId4", instanceId.applyValue(getServerDisksResult -> getServerDisksResult.disks()[0].id()));
        final var diskType = SimpleapplicationserverFunctions.getServerDisks(GetServerDisksArgs.builder()
            .diskType("System")
            .build());

        ctx.export("simpleApplicationServerDiskId5", diskType.applyValue(getServerDisksResult -> getServerDisksResult.disks()[0].id()));
    }
}

variables:
  ids:
    fn::invoke:
      function: alicloud:simpleapplicationserver:getServerDisks
      arguments:
        ids:
          - example_id
  nameRegex:
    fn::invoke:
      function: alicloud:simpleapplicationserver:getServerDisks
      arguments:
        nameRegex: ^my-Disk
  status:
    fn::invoke:
      function: alicloud:simpleapplicationserver:getServerDisks
      arguments:
        status: In_use
  instanceId:
    fn::invoke:
      function: alicloud:simpleapplicationserver:getServerDisks
      arguments:
        instanceId: example_value
  diskType:
    fn::invoke:
      function: alicloud:simpleapplicationserver:getServerDisks
      arguments:
        diskType: System
outputs:
  simpleApplicationServerDiskId1: ${ids.disks[0].id}
  simpleApplicationServerDiskId2: ${nameRegex.disks[0].id}
  simpleApplicationServerDiskId3: ${status.disks[0].id}
  simpleApplicationServerDiskId4: ${instanceId.disks[0].id}
  simpleApplicationServerDiskId5: ${diskType.disks[0].id}

function getServerDisks(args: GetServerDisksArgs, opts?: InvokeOptions): Promise<GetServerDisksResult>
function getServerDisksOutput(args: GetServerDisksOutputArgs, opts?: InvokeOptions): Output<GetServerDisksResult>

def get_server_disks(disk_type: Optional[str] = None,
                     ids: Optional[Sequence[str]] = None,
                     instance_id: Optional[str] = None,
                     name_regex: Optional[str] = None,
                     output_file: Optional[str] = None,
                     status: Optional[str] = None,
                     opts: Optional[InvokeOptions] = None) -> GetServerDisksResult
def get_server_disks_output(disk_type: Optional[pulumi.Input[str]] = None,
                     ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                     instance_id: Optional[pulumi.Input[str]] = None,
                     name_regex: Optional[pulumi.Input[str]] = None,
                     output_file: Optional[pulumi.Input[str]] = None,
                     status: Optional[pulumi.Input[str]] = None,
                     opts: Optional[InvokeOptions] = None) -> Output[GetServerDisksResult]

func GetServerDisks(ctx *Context, args *GetServerDisksArgs, opts ...InvokeOption) (*GetServerDisksResult, error)
func GetServerDisksOutput(ctx *Context, args *GetServerDisksOutputArgs, opts ...InvokeOption) GetServerDisksResultOutput

public static class GetServerDisks 
{
    public static Task<GetServerDisksResult> InvokeAsync(GetServerDisksArgs args, InvokeOptions? opts = null)
    public static Output<GetServerDisksResult> Invoke(GetServerDisksInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetServerDisksResult> getServerDisks(GetServerDisksArgs args, InvokeOptions options)
public static Output<GetServerDisksResult> getServerDisks(GetServerDisksArgs args, InvokeOptions options)

fn::invoke:
  function: alicloud:simpleapplicationserver/getServerDisks:getServerDisks
  arguments:
    # arguments dictionary