alicloud.eds.getDesktops

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

const defaultSimpleOfficeSite = new alicloud.eds.SimpleOfficeSite("default", {
    cidrBlock: "172.16.0.0/12",
    desktopAccessType: "Internet",
    officeSiteName: "your_office_site_name",
});
const default = alicloud.eds.getBundles({
    bundleType: "SYSTEM",
});
const defaultEcdPolicyGroup = new alicloud.eds.EcdPolicyGroup("default", {
    policyGroupName: "your_policy_group_name",
    clipboard: "readwrite",
    localDrive: "read",
    authorizeAccessPolicyRules: [{
        description: "example_value",
        cidrIp: "1.2.3.4/24",
    }],
    authorizeSecurityPolicyRules: [{
        type: "inflow",
        policy: "accept",
        description: "example_value",
        portRange: "80/80",
        ipProtocol: "TCP",
        priority: "1",
        cidrIp: "0.0.0.0/0",
    }],
});
const defaultUser = new alicloud.eds.User("default", {
    endUserId: "your_end_user_id",
    email: "your_email",
    phone: "your_phone",
    password: "your_password",
});
const defaultDesktop = new alicloud.eds.Desktop("default", {
    officeSiteId: defaultSimpleOfficeSite.id,
    policyGroupId: defaultEcdPolicyGroup.id,
    bundleId: _default.then(_default => _default.bundles?.[0]?.id),
    desktopName: "your_desktop_name",
    endUserIds: [defaultUser.id],
});
const ids = alicloud.eds.getDesktopsOutput({
    ids: [defaultDesktop.id],
});
export const ecdDesktopId1 = ids.apply(ids => ids.desktops?.[0]?.id);
const nameRegex = defaultDesktop.desktopName.apply(desktopName => alicloud.eds.getDesktopsOutput({
    nameRegex: desktopName,
}));
export const ecdDesktopId2 = nameRegex.apply(nameRegex => nameRegex.desktops?.[0]?.id);

import pulumi
import pulumi_alicloud as alicloud

default_simple_office_site = alicloud.eds.SimpleOfficeSite("default",
    cidr_block="172.16.0.0/12",
    desktop_access_type="Internet",
    office_site_name="your_office_site_name")
default = alicloud.eds.get_bundles(bundle_type="SYSTEM")
default_ecd_policy_group = alicloud.eds.EcdPolicyGroup("default",
    policy_group_name="your_policy_group_name",
    clipboard="readwrite",
    local_drive="read",
    authorize_access_policy_rules=[{
        "description": "example_value",
        "cidr_ip": "1.2.3.4/24",
    }],
    authorize_security_policy_rules=[{
        "type": "inflow",
        "policy": "accept",
        "description": "example_value",
        "port_range": "80/80",
        "ip_protocol": "TCP",
        "priority": "1",
        "cidr_ip": "0.0.0.0/0",
    }])
default_user = alicloud.eds.User("default",
    end_user_id="your_end_user_id",
    email="your_email",
    phone="your_phone",
    password="your_password")
default_desktop = alicloud.eds.Desktop("default",
    office_site_id=default_simple_office_site.id,
    policy_group_id=default_ecd_policy_group.id,
    bundle_id=default.bundles[0].id,
    desktop_name="your_desktop_name",
    end_user_ids=[default_user.id])
ids = alicloud.eds.get_desktops_output(ids=[default_desktop.id])
pulumi.export("ecdDesktopId1", ids.desktops[0].id)
name_regex = default_desktop.desktop_name.apply(lambda desktop_name: alicloud.eds.get_desktops_output(name_regex=desktop_name))
pulumi.export("ecdDesktopId2", name_regex.desktops[0].id)

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		defaultSimpleOfficeSite, err := eds.NewSimpleOfficeSite(ctx, "default", &eds.SimpleOfficeSiteArgs{
			CidrBlock:         pulumi.String("172.16.0.0/12"),
			DesktopAccessType: pulumi.String("Internet"),
			OfficeSiteName:    pulumi.String("your_office_site_name"),
		})
		if err != nil {
			return err
		}
		_default, err := eds.GetBundles(ctx, &eds.GetBundlesArgs{
			BundleType: pulumi.StringRef("SYSTEM"),
		}, nil)
		if err != nil {
			return err
		}
		defaultEcdPolicyGroup, err := eds.NewEcdPolicyGroup(ctx, "default", &eds.EcdPolicyGroupArgs{
			PolicyGroupName: pulumi.String("your_policy_group_name"),
			Clipboard:       pulumi.String("readwrite"),
			LocalDrive:      pulumi.String("read"),
			AuthorizeAccessPolicyRules: eds.EcdPolicyGroupAuthorizeAccessPolicyRuleArray{
				&eds.EcdPolicyGroupAuthorizeAccessPolicyRuleArgs{
					Description: pulumi.String("example_value"),
					CidrIp:      pulumi.String("1.2.3.4/24"),
				},
			},
			AuthorizeSecurityPolicyRules: eds.EcdPolicyGroupAuthorizeSecurityPolicyRuleArray{
				&eds.EcdPolicyGroupAuthorizeSecurityPolicyRuleArgs{
					Type:        pulumi.String("inflow"),
					Policy:      pulumi.String("accept"),
					Description: pulumi.String("example_value"),
					PortRange:   pulumi.String("80/80"),
					IpProtocol:  pulumi.String("TCP"),
					Priority:    pulumi.String("1"),
					CidrIp:      pulumi.String("0.0.0.0/0"),
				},
			},
		})
		if err != nil {
			return err
		}
		defaultUser, err := eds.NewUser(ctx, "default", &eds.UserArgs{
			EndUserId: pulumi.String("your_end_user_id"),
			Email:     pulumi.String("your_email"),
			Phone:     pulumi.String("your_phone"),
			Password:  pulumi.String("your_password"),
		})
		if err != nil {
			return err
		}
		defaultDesktop, err := eds.NewDesktop(ctx, "default", &eds.DesktopArgs{
			OfficeSiteId:  defaultSimpleOfficeSite.ID(),
			PolicyGroupId: defaultEcdPolicyGroup.ID(),
			BundleId:      pulumi.String(_default.Bundles[0].Id),
			DesktopName:   pulumi.String("your_desktop_name"),
			EndUserIds: pulumi.StringArray{
				defaultUser.ID(),
			},
		})
		if err != nil {
			return err
		}
		ids := eds.GetDesktopsOutput(ctx, eds.GetDesktopsOutputArgs{
			Ids: pulumi.StringArray{
				defaultDesktop.ID(),
			},
		}, nil)
		ctx.Export("ecdDesktopId1", ids.ApplyT(func(ids eds.GetDesktopsResult) (*string, error) {
			return &ids.Desktops[0].Id, nil
		}).(pulumi.StringPtrOutput))
		nameRegex := defaultDesktop.DesktopName.ApplyT(func(desktopName *string) (eds.GetDesktopsResult, error) {
			return eds.GetDesktopsResult(interface{}(eds.GetDesktopsOutput(ctx, eds.GetDesktopsOutputArgs{
				NameRegex: desktopName,
			}, nil))), nil
		}).(eds.GetDesktopsResultOutput)
		ctx.Export("ecdDesktopId2", nameRegex.ApplyT(func(nameRegex eds.GetDesktopsResult) (*string, error) {
			return &nameRegex.Desktops[0].Id, nil
		}).(pulumi.StringPtrOutput))
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var defaultSimpleOfficeSite = new AliCloud.Eds.SimpleOfficeSite("default", new()
    {
        CidrBlock = "172.16.0.0/12",
        DesktopAccessType = "Internet",
        OfficeSiteName = "your_office_site_name",
    });

    var @default = AliCloud.Eds.GetBundles.Invoke(new()
    {
        BundleType = "SYSTEM",
    });

    var defaultEcdPolicyGroup = new AliCloud.Eds.EcdPolicyGroup("default", new()
    {
        PolicyGroupName = "your_policy_group_name",
        Clipboard = "readwrite",
        LocalDrive = "read",
        AuthorizeAccessPolicyRules = new[]
        {
            new AliCloud.Eds.Inputs.EcdPolicyGroupAuthorizeAccessPolicyRuleArgs
            {
                Description = "example_value",
                CidrIp = "1.2.3.4/24",
            },
        },
        AuthorizeSecurityPolicyRules = new[]
        {
            new AliCloud.Eds.Inputs.EcdPolicyGroupAuthorizeSecurityPolicyRuleArgs
            {
                Type = "inflow",
                Policy = "accept",
                Description = "example_value",
                PortRange = "80/80",
                IpProtocol = "TCP",
                Priority = "1",
                CidrIp = "0.0.0.0/0",
            },
        },
    });

    var defaultUser = new AliCloud.Eds.User("default", new()
    {
        EndUserId = "your_end_user_id",
        Email = "your_email",
        Phone = "your_phone",
        Password = "your_password",
    });

    var defaultDesktop = new AliCloud.Eds.Desktop("default", new()
    {
        OfficeSiteId = defaultSimpleOfficeSite.Id,
        PolicyGroupId = defaultEcdPolicyGroup.Id,
        BundleId = @default.Apply(@default => @default.Apply(getBundlesResult => getBundlesResult.Bundles[0]?.Id)),
        DesktopName = "your_desktop_name",
        EndUserIds = new[]
        {
            defaultUser.Id,
        },
    });

    var ids = AliCloud.Eds.GetDesktops.Invoke(new()
    {
        Ids = new[]
        {
            defaultDesktop.Id,
        },
    });

    var nameRegex = AliCloud.Eds.GetDesktops.Invoke(new()
    {
        NameRegex = defaultDesktop.DesktopName,
    });

    return new Dictionary<string, object?>
    {
        ["ecdDesktopId1"] = ids.Apply(getDesktopsResult => getDesktopsResult.Desktops[0]?.Id),
        ["ecdDesktopId2"] = nameRegex.Apply(getDesktopsResult => getDesktopsResult.Desktops[0]?.Id),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.alicloud.eds.SimpleOfficeSite;
import com.pulumi.alicloud.eds.SimpleOfficeSiteArgs;
import com.pulumi.alicloud.eds.EdsFunctions;
import com.pulumi.alicloud.eds.inputs.GetBundlesArgs;
import com.pulumi.alicloud.eds.EcdPolicyGroup;
import com.pulumi.alicloud.eds.EcdPolicyGroupArgs;
import com.pulumi.alicloud.eds.inputs.EcdPolicyGroupAuthorizeAccessPolicyRuleArgs;
import com.pulumi.alicloud.eds.inputs.EcdPolicyGroupAuthorizeSecurityPolicyRuleArgs;
import com.pulumi.alicloud.eds.User;
import com.pulumi.alicloud.eds.UserArgs;
import com.pulumi.alicloud.eds.Desktop;
import com.pulumi.alicloud.eds.DesktopArgs;
import com.pulumi.alicloud.eds.inputs.GetDesktopsArgs;
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) {
        var defaultSimpleOfficeSite = new SimpleOfficeSite("defaultSimpleOfficeSite", SimpleOfficeSiteArgs.builder()
            .cidrBlock("172.16.0.0/12")
            .desktopAccessType("Internet")
            .officeSiteName("your_office_site_name")
            .build());

        final var default = EdsFunctions.getBundles(GetBundlesArgs.builder()
            .bundleType("SYSTEM")
            .build());

        var defaultEcdPolicyGroup = new EcdPolicyGroup("defaultEcdPolicyGroup", EcdPolicyGroupArgs.builder()
            .policyGroupName("your_policy_group_name")
            .clipboard("readwrite")
            .localDrive("read")
            .authorizeAccessPolicyRules(EcdPolicyGroupAuthorizeAccessPolicyRuleArgs.builder()
                .description("example_value")
                .cidrIp("1.2.3.4/24")
                .build())
            .authorizeSecurityPolicyRules(EcdPolicyGroupAuthorizeSecurityPolicyRuleArgs.builder()
                .type("inflow")
                .policy("accept")
                .description("example_value")
                .portRange("80/80")
                .ipProtocol("TCP")
                .priority("1")
                .cidrIp("0.0.0.0/0")
                .build())
            .build());

        var defaultUser = new User("defaultUser", UserArgs.builder()
            .endUserId("your_end_user_id")
            .email("your_email")
            .phone("your_phone")
            .password("your_password")
            .build());

        var defaultDesktop = new Desktop("defaultDesktop", DesktopArgs.builder()
            .officeSiteId(defaultSimpleOfficeSite.id())
            .policyGroupId(defaultEcdPolicyGroup.id())
            .bundleId(default_.bundles()[0].id())
            .desktopName("your_desktop_name")
            .endUserIds(defaultUser.id())
            .build());

        final var ids = EdsFunctions.getDesktops(GetDesktopsArgs.builder()
            .ids(defaultDesktop.id())
            .build());

        ctx.export("ecdDesktopId1", ids.applyValue(getDesktopsResult -> getDesktopsResult).applyValue(ids -> ids.applyValue(getDesktopsResult -> getDesktopsResult.desktops()[0].id())));
        final var nameRegex = EdsFunctions.getDesktops(GetDesktopsArgs.builder()
            .nameRegex(defaultDesktop.desktopName())
            .build());

        ctx.export("ecdDesktopId2", nameRegex.applyValue(getDesktopsResult -> getDesktopsResult).applyValue(nameRegex -> nameRegex.applyValue(getDesktopsResult -> getDesktopsResult.desktops()[0].id())));
    }
}

resources:
  defaultSimpleOfficeSite:
    type: alicloud:eds:SimpleOfficeSite
    name: default
    properties:
      cidrBlock: 172.16.0.0/12
      desktopAccessType: Internet
      officeSiteName: your_office_site_name
  defaultEcdPolicyGroup:
    type: alicloud:eds:EcdPolicyGroup
    name: default
    properties:
      policyGroupName: your_policy_group_name
      clipboard: readwrite
      localDrive: read
      authorizeAccessPolicyRules:
        - description: example_value
          cidrIp: 1.2.3.4/24
      authorizeSecurityPolicyRules:
        - type: inflow
          policy: accept
          description: example_value
          portRange: 80/80
          ipProtocol: TCP
          priority: '1'
          cidrIp: 0.0.0.0/0
  defaultDesktop:
    type: alicloud:eds:Desktop
    name: default
    properties:
      officeSiteId: ${defaultSimpleOfficeSite.id}
      policyGroupId: ${defaultEcdPolicyGroup.id}
      bundleId: ${default.bundles[0].id}
      desktopName: your_desktop_name
      endUserIds:
        - ${defaultUser.id}
  defaultUser:
    type: alicloud:eds:User
    name: default
    properties:
      endUserId: your_end_user_id
      email: your_email
      phone: your_phone
      password: your_password
variables:
  default:
    fn::invoke:
      Function: alicloud:eds:getBundles
      Arguments:
        bundleType: SYSTEM
  ids:
    fn::invoke:
      Function: alicloud:eds:getDesktops
      Arguments:
        ids:
          - ${defaultDesktop.id}
  nameRegex:
    fn::invoke:
      Function: alicloud:eds:getDesktops
      Arguments:
        nameRegex: ${defaultDesktop.desktopName}
outputs:
  ecdDesktopId1: ${ids.desktops[0].id}
  ecdDesktopId2: ${nameRegex.desktops[0].id}

function getDesktops(args: GetDesktopsArgs, opts?: InvokeOptions): Promise<GetDesktopsResult>
function getDesktopsOutput(args: GetDesktopsOutputArgs, opts?: InvokeOptions): Output<GetDesktopsResult>

def get_desktops(desktop_name: Optional[str] = None,
                 end_user_ids: Optional[Sequence[str]] = None,
                 ids: Optional[Sequence[str]] = None,
                 name_regex: Optional[str] = None,
                 office_site_id: Optional[str] = None,
                 output_file: Optional[str] = None,
                 policy_group_id: Optional[str] = None,
                 status: Optional[str] = None,
                 opts: Optional[InvokeOptions] = None) -> GetDesktopsResult
def get_desktops_output(desktop_name: Optional[pulumi.Input[str]] = None,
                 end_user_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 name_regex: Optional[pulumi.Input[str]] = None,
                 office_site_id: Optional[pulumi.Input[str]] = None,
                 output_file: Optional[pulumi.Input[str]] = None,
                 policy_group_id: Optional[pulumi.Input[str]] = None,
                 status: Optional[pulumi.Input[str]] = None,
                 opts: Optional[InvokeOptions] = None) -> Output[GetDesktopsResult]

func GetDesktops(ctx *Context, args *GetDesktopsArgs, opts ...InvokeOption) (*GetDesktopsResult, error)
func GetDesktopsOutput(ctx *Context, args *GetDesktopsOutputArgs, opts ...InvokeOption) GetDesktopsResultOutput

public static class GetDesktops 
{
    public static Task<GetDesktopsResult> InvokeAsync(GetDesktopsArgs args, InvokeOptions? opts = null)
    public static Output<GetDesktopsResult> Invoke(GetDesktopsInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetDesktopsResult> getDesktops(GetDesktopsArgs args, InvokeOptions options)
// Output-based functions aren't available in Java yet

fn::invoke:
  function: alicloud:eds/getDesktops:getDesktops
  arguments:
    # arguments dictionary