pulumi-azure-kotlin/com.pulumi.azure.desktopvirtualization.kotlin/ScalingPlanHostPoolAssociationArgs

ScalingPlanHostPoolAssociationArgs

data class ScalingPlanHostPoolAssociationArgs(val enabled: Output<Boolean>? = null, val hostPoolId: Output<String>? = null, val scalingPlanId: Output<String>? = null) : ConvertibleToJava<ScalingPlanHostPoolAssociationArgs>

Manages a Virtual Desktop Scaling Plan Host Pool Association.

Example Usage

import * as pulumi from "@pulumi/pulumi";
import * as azure from "@pulumi/azure";
import * as azuread from "@pulumi/azuread";
const exampleResourceGroup = new azure.core.ResourceGroup("example", {
    name: "rg-example-virtualdesktop",
    location: "West Europe",
});
const example = azuread.getServicePrincipal({
    displayName: "Windows Virtual Desktop",
});
const exampleAssignment = new azure.authorization.Assignment("example", {
    scope: exampleResourceGroup.id,
    roleDefinitionName: "Desktop Virtualization Power On Off Contributor",
    principalId: example.then(example => example.objectId),
});
const exampleHostPool = new azure.desktopvirtualization.HostPool("example", {
    name: "example-hostpool",
    location: exampleResourceGroup.location,
    resourceGroupName: exampleResourceGroup.name,
    type: "Pooled",
    validateEnvironment: true,
    loadBalancerType: "BreadthFirst",
});
const exampleScalingPlan = new azure.desktopvirtualization.ScalingPlan("example", {
    name: "example-scaling-plan",
    location: exampleResourceGroup.location,
    resourceGroupName: exampleResourceGroup.name,
    friendlyName: "Scaling Plan Test",
    description: "Test Scaling Plan",
    timeZone: "GMT Standard Time",
    schedules: [{
        name: "Weekdays",
        daysOfWeeks: [
            "Monday",
            "Tuesday",
            "Wednesday",
            "Thursday",
            "Friday",
        ],
        rampUpStartTime: "06:00",
        rampUpLoadBalancingAlgorithm: "BreadthFirst",
        rampUpMinimumHostsPercent: 20,
        rampUpCapacityThresholdPercent: 10,
        peakStartTime: "09:00",
        peakLoadBalancingAlgorithm: "BreadthFirst",
        rampDownStartTime: "18:00",
        rampDownLoadBalancingAlgorithm: "BreadthFirst",
        rampDownMinimumHostsPercent: 10,
        rampDownForceLogoffUsers: false,
        rampDownWaitTimeMinutes: 45,
        rampDownNotificationMessage: "Please log of in the next 45 minutes...",
        rampDownCapacityThresholdPercent: 5,
        rampDownStopHostsWhen: "ZeroSessions",
        offPeakStartTime: "22:00",
        offPeakLoadBalancingAlgorithm: "BreadthFirst",
    }],
}, {
    dependsOn: [exampleAssignment],
});
const exampleScalingPlanHostPoolAssociation = new azure.desktopvirtualization.ScalingPlanHostPoolAssociation("example", {
    hostPoolId: exampleHostPool.id,
    scalingPlanId: exampleScalingPlan.id,
    enabled: true,
}, {
    dependsOn: [exampleAssignment],
});

import pulumi
import pulumi_azure as azure
import pulumi_azuread as azuread
example_resource_group = azure.core.ResourceGroup("example",
    name="rg-example-virtualdesktop",
    location="West Europe")
example = azuread.get_service_principal(display_name="Windows Virtual Desktop")
example_assignment = azure.authorization.Assignment("example",
    scope=example_resource_group.id,
    role_definition_name="Desktop Virtualization Power On Off Contributor",
    principal_id=example.object_id)
example_host_pool = azure.desktopvirtualization.HostPool("example",
    name="example-hostpool",
    location=example_resource_group.location,
    resource_group_name=example_resource_group.name,
    type="Pooled",
    validate_environment=True,
    load_balancer_type="BreadthFirst")
example_scaling_plan = azure.desktopvirtualization.ScalingPlan("example",
    name="example-scaling-plan",
    location=example_resource_group.location,
    resource_group_name=example_resource_group.name,
    friendly_name="Scaling Plan Test",
    description="Test Scaling Plan",
    time_zone="GMT Standard Time",
    schedules=[{
        "name": "Weekdays",
        "days_of_weeks": [
            "Monday",
            "Tuesday",
            "Wednesday",
            "Thursday",
            "Friday",
        ],
        "ramp_up_start_time": "06:00",
        "ramp_up_load_balancing_algorithm": "BreadthFirst",
        "ramp_up_minimum_hosts_percent": 20,
        "ramp_up_capacity_threshold_percent": 10,
        "peak_start_time": "09:00",
        "peak_load_balancing_algorithm": "BreadthFirst",
        "ramp_down_start_time": "18:00",
        "ramp_down_load_balancing_algorithm": "BreadthFirst",
        "ramp_down_minimum_hosts_percent": 10,
        "ramp_down_force_logoff_users": False,
        "ramp_down_wait_time_minutes": 45,
        "ramp_down_notification_message": "Please log of in the next 45 minutes...",
        "ramp_down_capacity_threshold_percent": 5,
        "ramp_down_stop_hosts_when": "ZeroSessions",
        "off_peak_start_time": "22:00",
        "off_peak_load_balancing_algorithm": "BreadthFirst",
    }],
    opts = pulumi.ResourceOptions(depends_on=[example_assignment]))
example_scaling_plan_host_pool_association = azure.desktopvirtualization.ScalingPlanHostPoolAssociation("example",
    host_pool_id=example_host_pool.id,
    scaling_plan_id=example_scaling_plan.id,
    enabled=True,
    opts = pulumi.ResourceOptions(depends_on=[example_assignment]))

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Azure = Pulumi.Azure;
using AzureAD = Pulumi.AzureAD;
return await Deployment.RunAsync(() =>
{
    var exampleResourceGroup = new Azure.Core.ResourceGroup("example", new()
    {
        Name = "rg-example-virtualdesktop",
        Location = "West Europe",
    });
    var example = AzureAD.GetServicePrincipal.Invoke(new()
    {
        DisplayName = "Windows Virtual Desktop",
    });
    var exampleAssignment = new Azure.Authorization.Assignment("example", new()
    {
        Scope = exampleResourceGroup.Id,
        RoleDefinitionName = "Desktop Virtualization Power On Off Contributor",
        PrincipalId = example.Apply(getServicePrincipalResult => getServicePrincipalResult.ObjectId),
    });
    var exampleHostPool = new Azure.DesktopVirtualization.HostPool("example", new()
    {
        Name = "example-hostpool",
        Location = exampleResourceGroup.Location,
        ResourceGroupName = exampleResourceGroup.Name,
        Type = "Pooled",
        ValidateEnvironment = true,
        LoadBalancerType = "BreadthFirst",
    });
    var exampleScalingPlan = new Azure.DesktopVirtualization.ScalingPlan("example", new()
    {
        Name = "example-scaling-plan",
        Location = exampleResourceGroup.Location,
        ResourceGroupName = exampleResourceGroup.Name,
        FriendlyName = "Scaling Plan Test",
        Description = "Test Scaling Plan",
        TimeZone = "GMT Standard Time",
        Schedules = new[]
        {
            new Azure.DesktopVirtualization.Inputs.ScalingPlanScheduleArgs
            {
                Name = "Weekdays",
                DaysOfWeeks = new[]
                {
                    "Monday",
                    "Tuesday",
                    "Wednesday",
                    "Thursday",
                    "Friday",
                },
                RampUpStartTime = "06:00",
                RampUpLoadBalancingAlgorithm = "BreadthFirst",
                RampUpMinimumHostsPercent = 20,
                RampUpCapacityThresholdPercent = 10,
                PeakStartTime = "09:00",
                PeakLoadBalancingAlgorithm = "BreadthFirst",
                RampDownStartTime = "18:00",
                RampDownLoadBalancingAlgorithm = "BreadthFirst",
                RampDownMinimumHostsPercent = 10,
                RampDownForceLogoffUsers = false,
                RampDownWaitTimeMinutes = 45,
                RampDownNotificationMessage = "Please log of in the next 45 minutes...",
                RampDownCapacityThresholdPercent = 5,
                RampDownStopHostsWhen = "ZeroSessions",
                OffPeakStartTime = "22:00",
                OffPeakLoadBalancingAlgorithm = "BreadthFirst",
            },
        },
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            exampleAssignment,
        },
    });
    var exampleScalingPlanHostPoolAssociation = new Azure.DesktopVirtualization.ScalingPlanHostPoolAssociation("example", new()
    {
        HostPoolId = exampleHostPool.Id,
        ScalingPlanId = exampleScalingPlan.Id,
        Enabled = true,
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            exampleAssignment,
        },
    });
});

package main
import (
	"github.com/pulumi/pulumi-azure/sdk/v6/go/azure/authorization"
	"github.com/pulumi/pulumi-azure/sdk/v6/go/azure/core"
	"github.com/pulumi/pulumi-azure/sdk/v6/go/azure/desktopvirtualization"
	"github.com/pulumi/pulumi-azuread/sdk/v5/go/azuread"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleResourceGroup, err := core.NewResourceGroup(ctx, "example", &core.ResourceGroupArgs{
			Name:     pulumi.String("rg-example-virtualdesktop"),
			Location: pulumi.String("West Europe"),
		})
		if err != nil {
			return err
		}
		example, err := azuread.LookupServicePrincipal(ctx, &azuread.LookupServicePrincipalArgs{
			DisplayName: pulumi.StringRef("Windows Virtual Desktop"),
		}, nil)
		if err != nil {
			return err
		}
		exampleAssignment, err := authorization.NewAssignment(ctx, "example", &authorization.AssignmentArgs{
			Scope:              exampleResourceGroup.ID(),
			RoleDefinitionName: pulumi.String("Desktop Virtualization Power On Off Contributor"),
			PrincipalId:        pulumi.String(example.ObjectId),
		})
		if err != nil {
			return err
		}
		exampleHostPool, err := desktopvirtualization.NewHostPool(ctx, "example", &desktopvirtualization.HostPoolArgs{
			Name:                pulumi.String("example-hostpool"),
			Location:            exampleResourceGroup.Location,
			ResourceGroupName:   exampleResourceGroup.Name,
			Type:                pulumi.String("Pooled"),
			ValidateEnvironment: pulumi.Bool(true),
			LoadBalancerType:    pulumi.String("BreadthFirst"),
		})
		if err != nil {
			return err
		}
		exampleScalingPlan, err := desktopvirtualization.NewScalingPlan(ctx, "example", &desktopvirtualization.ScalingPlanArgs{
			Name:              pulumi.String("example-scaling-plan"),
			Location:          exampleResourceGroup.Location,
			ResourceGroupName: exampleResourceGroup.Name,
			FriendlyName:      pulumi.String("Scaling Plan Test"),
			Description:       pulumi.String("Test Scaling Plan"),
			TimeZone:          pulumi.String("GMT Standard Time"),
			Schedules: desktopvirtualization.ScalingPlanScheduleArray{
				&desktopvirtualization.ScalingPlanScheduleArgs{
					Name: pulumi.String("Weekdays"),
					DaysOfWeeks: pulumi.StringArray{
						pulumi.String("Monday"),
						pulumi.String("Tuesday"),
						pulumi.String("Wednesday"),
						pulumi.String("Thursday"),
						pulumi.String("Friday"),
					},
					RampUpStartTime:                  pulumi.String("06:00"),
					RampUpLoadBalancingAlgorithm:     pulumi.String("BreadthFirst"),
					RampUpMinimumHostsPercent:        pulumi.Int(20),
					RampUpCapacityThresholdPercent:   pulumi.Int(10),
					PeakStartTime:                    pulumi.String("09:00"),
					PeakLoadBalancingAlgorithm:       pulumi.String("BreadthFirst"),
					RampDownStartTime:                pulumi.String("18:00"),
					RampDownLoadBalancingAlgorithm:   pulumi.String("BreadthFirst"),
					RampDownMinimumHostsPercent:      pulumi.Int(10),
					RampDownForceLogoffUsers:         pulumi.Bool(false),
					RampDownWaitTimeMinutes:          pulumi.Int(45),
					RampDownNotificationMessage:      pulumi.String("Please log of in the next 45 minutes..."),
					RampDownCapacityThresholdPercent: pulumi.Int(5),
					RampDownStopHostsWhen:            pulumi.String("ZeroSessions"),
					OffPeakStartTime:                 pulumi.String("22:00"),
					OffPeakLoadBalancingAlgorithm:    pulumi.String("BreadthFirst"),
				},
			},
		}, pulumi.DependsOn([]pulumi.Resource{
			exampleAssignment,
		}))
		if err != nil {
			return err
		}
		_, err = desktopvirtualization.NewScalingPlanHostPoolAssociation(ctx, "example", &desktopvirtualization.ScalingPlanHostPoolAssociationArgs{
			HostPoolId:    exampleHostPool.ID(),
			ScalingPlanId: exampleScalingPlan.ID(),
			Enabled:       pulumi.Bool(true),
		}, pulumi.DependsOn([]pulumi.Resource{
			exampleAssignment,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azure.core.ResourceGroup;
import com.pulumi.azure.core.ResourceGroupArgs;
import com.pulumi.azuread.AzureadFunctions;
import com.pulumi.azuread.inputs.GetServicePrincipalArgs;
import com.pulumi.azure.authorization.Assignment;
import com.pulumi.azure.authorization.AssignmentArgs;
import com.pulumi.azure.desktopvirtualization.HostPool;
import com.pulumi.azure.desktopvirtualization.HostPoolArgs;
import com.pulumi.azure.desktopvirtualization.ScalingPlan;
import com.pulumi.azure.desktopvirtualization.ScalingPlanArgs;
import com.pulumi.azure.desktopvirtualization.inputs.ScalingPlanScheduleArgs;
import com.pulumi.azure.desktopvirtualization.ScalingPlanHostPoolAssociation;
import com.pulumi.azure.desktopvirtualization.ScalingPlanHostPoolAssociationArgs;
import com.pulumi.resources.CustomResourceOptions;
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 exampleResourceGroup = new ResourceGroup("exampleResourceGroup", ResourceGroupArgs.builder()
            .name("rg-example-virtualdesktop")
            .location("West Europe")
            .build());
        final var example = AzureadFunctions.getServicePrincipal(GetServicePrincipalArgs.builder()
            .displayName("Windows Virtual Desktop")
            .build());
        var exampleAssignment = new Assignment("exampleAssignment", AssignmentArgs.builder()
            .scope(exampleResourceGroup.id())
            .roleDefinitionName("Desktop Virtualization Power On Off Contributor")
            .principalId(example.applyValue(getServicePrincipalResult -> getServicePrincipalResult.objectId()))
            .build());
        var exampleHostPool = new HostPool("exampleHostPool", HostPoolArgs.builder()
            .name("example-hostpool")
            .location(exampleResourceGroup.location())
            .resourceGroupName(exampleResourceGroup.name())
            .type("Pooled")
            .validateEnvironment(true)
            .loadBalancerType("BreadthFirst")
            .build());
        var exampleScalingPlan = new ScalingPlan("exampleScalingPlan", ScalingPlanArgs.builder()
            .name("example-scaling-plan")
            .location(exampleResourceGroup.location())
            .resourceGroupName(exampleResourceGroup.name())
            .friendlyName("Scaling Plan Test")
            .description("Test Scaling Plan")
            .timeZone("GMT Standard Time")
            .schedules(ScalingPlanScheduleArgs.builder()
                .name("Weekdays")
                .daysOfWeeks(
                    "Monday",
                    "Tuesday",
                    "Wednesday",
                    "Thursday",
                    "Friday")
                .rampUpStartTime("06:00")
                .rampUpLoadBalancingAlgorithm("BreadthFirst")
                .rampUpMinimumHostsPercent(20)
                .rampUpCapacityThresholdPercent(10)
                .peakStartTime("09:00")
                .peakLoadBalancingAlgorithm("BreadthFirst")
                .rampDownStartTime("18:00")
                .rampDownLoadBalancingAlgorithm("BreadthFirst")
                .rampDownMinimumHostsPercent(10)
                .rampDownForceLogoffUsers(false)
                .rampDownWaitTimeMinutes(45)
                .rampDownNotificationMessage("Please log of in the next 45 minutes...")
                .rampDownCapacityThresholdPercent(5)
                .rampDownStopHostsWhen("ZeroSessions")
                .offPeakStartTime("22:00")
                .offPeakLoadBalancingAlgorithm("BreadthFirst")
                .build())
            .build(), CustomResourceOptions.builder()
                .dependsOn(exampleAssignment)
                .build());
        var exampleScalingPlanHostPoolAssociation = new ScalingPlanHostPoolAssociation("exampleScalingPlanHostPoolAssociation", ScalingPlanHostPoolAssociationArgs.builder()
            .hostPoolId(exampleHostPool.id())
            .scalingPlanId(exampleScalingPlan.id())
            .enabled(true)
            .build(), CustomResourceOptions.builder()
                .dependsOn(exampleAssignment)
                .build());
    }
}

resources:
  exampleResourceGroup:
    type: azure:core:ResourceGroup
    name: example
    properties:
      name: rg-example-virtualdesktop
      location: West Europe
  exampleAssignment:
    type: azure:authorization:Assignment
    name: example
    properties:
      scope: ${exampleResourceGroup.id}
      roleDefinitionName: Desktop Virtualization Power On Off Contributor
      principalId: ${example.objectId}
  exampleHostPool:
    type: azure:desktopvirtualization:HostPool
    name: example
    properties:
      name: example-hostpool
      location: ${exampleResourceGroup.location}
      resourceGroupName: ${exampleResourceGroup.name}
      type: Pooled
      validateEnvironment: true
      loadBalancerType: BreadthFirst
  exampleScalingPlan:
    type: azure:desktopvirtualization:ScalingPlan
    name: example
    properties:
      name: example-scaling-plan
      location: ${exampleResourceGroup.location}
      resourceGroupName: ${exampleResourceGroup.name}
      friendlyName: Scaling Plan Test
      description: Test Scaling Plan
      timeZone: GMT Standard Time
      schedules:
        - name: Weekdays
          daysOfWeeks:
            - Monday
            - Tuesday
            - Wednesday
            - Thursday
            - Friday
          rampUpStartTime: 06:00
          rampUpLoadBalancingAlgorithm: BreadthFirst
          rampUpMinimumHostsPercent: 20
          rampUpCapacityThresholdPercent: 10
          peakStartTime: 09:00
          peakLoadBalancingAlgorithm: BreadthFirst
          rampDownStartTime: 18:00
          rampDownLoadBalancingAlgorithm: BreadthFirst
          rampDownMinimumHostsPercent: 10
          rampDownForceLogoffUsers: false
          rampDownWaitTimeMinutes: 45
          rampDownNotificationMessage: Please log of in the next 45 minutes...
          rampDownCapacityThresholdPercent: 5
          rampDownStopHostsWhen: ZeroSessions
          offPeakStartTime: 22:00
          offPeakLoadBalancingAlgorithm: BreadthFirst
    options:
      dependsOn:
        - ${exampleAssignment}
  exampleScalingPlanHostPoolAssociation:
    type: azure:desktopvirtualization:ScalingPlanHostPoolAssociation
    name: example
    properties:
      hostPoolId: ${exampleHostPool.id}
      scalingPlanId: ${exampleScalingPlan.id}
      enabled: true
    options:
      dependsOn:
        - ${exampleAssignment}
variables:
  example:
    fn::invoke:
      function: azuread:getServicePrincipal
      arguments:
        displayName: Windows Virtual Desktop

Import

Associations between Virtual Desktop Scaling Plans and Virtual Desktop Host Pools can be imported using the resource id, e.g.

$ pulumi import azure:desktopvirtualization/scalingPlanHostPoolAssociation:ScalingPlanHostPoolAssociation example "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/resGroup1/providers/Microsoft.DesktopVirtualization/scalingPlans/plan1|/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myGroup1/providers/Microsoft.DesktopVirtualization/hostPools/myhostpool"

Constructors

ScalingPlanHostPoolAssociationArgs

constructor(enabled: Output<Boolean>? = null, hostPoolId: Output<String>? = null, scalingPlanId: Output<String>? = null)

Properties

enabled

val enabled: Output<Boolean>? = null

Should the Scaling Plan be enabled on this Host Pool.

hostPoolId

val hostPoolId: Output<String>? = null

The resource ID for the Virtual Desktop Host Pool. Changing this forces a new resource to be created.

scalingPlanId

val scalingPlanId: Output<String>? = null

The resource ID for the Virtual Desktop Scaling Plan. Changing this forces a new resource to be created.

Functions

toJava

open override fun toJava(): ScalingPlanHostPoolAssociationArgs