ElasticityAssuranceArgs

import * as pulumi from "@pulumi/pulumi";
import * as alicloud from "@pulumi/alicloud";
const _default = alicloud.resourcemanager.getResourceGroups({
    status: "OK",
});
const defaultGetZones = alicloud.getZones({
    availableResourceCreation: "Instance",
});
const defaultGetInstanceTypes = alicloud.ecs.getInstanceTypes({
    instanceTypeFamily: "ecs.c6",
});
const defaultElasticityAssurance = new alicloud.ecs.ElasticityAssurance("default", {
    instanceAmount: 1,
    description: "before",
    zoneIds: [defaultGetZones.then(defaultGetZones => defaultGetZones.zones?.[2]?.id)],
    privatePoolOptionsName: "test_before",
    period: 1,
    privatePoolOptionsMatchCriteria: "Open",
    instanceType: defaultGetInstanceTypes.then(defaultGetInstanceTypes => defaultGetInstanceTypes.instanceTypes?.[0]?.id),
    periodUnit: "Month",
    assuranceTimes: "Unlimited",
    resourceGroupId: _default.then(_default => _default.ids?.[0]),
});

import pulumi
import pulumi_alicloud as alicloud
default = alicloud.resourcemanager.get_resource_groups(status="OK")
default_get_zones = alicloud.get_zones(available_resource_creation="Instance")
default_get_instance_types = alicloud.ecs.get_instance_types(instance_type_family="ecs.c6")
default_elasticity_assurance = alicloud.ecs.ElasticityAssurance("default",
    instance_amount=1,
    description="before",
    zone_ids=[default_get_zones.zones[2].id],
    private_pool_options_name="test_before",
    period=1,
    private_pool_options_match_criteria="Open",
    instance_type=default_get_instance_types.instance_types[0].id,
    period_unit="Month",
    assurance_times="Unlimited",
    resource_group_id=default.ids[0])

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AliCloud = Pulumi.AliCloud;
return await Deployment.RunAsync(() =>
{
    var @default = AliCloud.ResourceManager.GetResourceGroups.Invoke(new()
    {
        Status = "OK",
    });
    var defaultGetZones = AliCloud.GetZones.Invoke(new()
    {
        AvailableResourceCreation = "Instance",
    });
    var defaultGetInstanceTypes = AliCloud.Ecs.GetInstanceTypes.Invoke(new()
    {
        InstanceTypeFamily = "ecs.c6",
    });
    var defaultElasticityAssurance = new AliCloud.Ecs.ElasticityAssurance("default", new()
    {
        InstanceAmount = 1,
        Description = "before",
        ZoneIds = new[]
        {
            defaultGetZones.Apply(getZonesResult => getZonesResult.Zones[2]?.Id),
        },
        PrivatePoolOptionsName = "test_before",
        Period = 1,
        PrivatePoolOptionsMatchCriteria = "Open",
        InstanceType = defaultGetInstanceTypes.Apply(getInstanceTypesResult => getInstanceTypesResult.InstanceTypes[0]?.Id),
        PeriodUnit = "Month",
        AssuranceTimes = "Unlimited",
        ResourceGroupId = @default.Apply(@default => @default.Apply(getResourceGroupsResult => getResourceGroupsResult.Ids[0])),
    });
});

package main
import (
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud"
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/ecs"
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/resourcemanager"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_default, err := resourcemanager.GetResourceGroups(ctx, &resourcemanager.GetResourceGroupsArgs{
			Status: pulumi.StringRef("OK"),
		}, nil)
		if err != nil {
			return err
		}
		defaultGetZones, err := alicloud.GetZones(ctx, &alicloud.GetZonesArgs{
			AvailableResourceCreation: pulumi.StringRef("Instance"),
		}, nil)
		if err != nil {
			return err
		}
		defaultGetInstanceTypes, err := ecs.GetInstanceTypes(ctx, &ecs.GetInstanceTypesArgs{
			InstanceTypeFamily: pulumi.StringRef("ecs.c6"),
		}, nil)
		if err != nil {
			return err
		}
		_, err = ecs.NewElasticityAssurance(ctx, "default", &ecs.ElasticityAssuranceArgs{
			InstanceAmount: pulumi.Int(1),
			Description:    pulumi.String("before"),
			ZoneIds: pulumi.StringArray{
				pulumi.String(defaultGetZones.Zones[2].Id),
			},
			PrivatePoolOptionsName:          pulumi.String("test_before"),
			Period:                          pulumi.Int(1),
			PrivatePoolOptionsMatchCriteria: pulumi.String("Open"),
			InstanceType:                    pulumi.String(defaultGetInstanceTypes.InstanceTypes[0].Id),
			PeriodUnit:                      pulumi.String("Month"),
			AssuranceTimes:                  pulumi.String("Unlimited"),
			ResourceGroupId:                 pulumi.String(_default.Ids[0]),
		})
		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.alicloud.resourcemanager.ResourcemanagerFunctions;
import com.pulumi.alicloud.resourcemanager.inputs.GetResourceGroupsArgs;
import com.pulumi.alicloud.AlicloudFunctions;
import com.pulumi.alicloud.inputs.GetZonesArgs;
import com.pulumi.alicloud.ecs.EcsFunctions;
import com.pulumi.alicloud.ecs.inputs.GetInstanceTypesArgs;
import com.pulumi.alicloud.ecs.ElasticityAssurance;
import com.pulumi.alicloud.ecs.ElasticityAssuranceArgs;
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 default = ResourcemanagerFunctions.getResourceGroups(GetResourceGroupsArgs.builder()
            .status("OK")
            .build());
        final var defaultGetZones = AlicloudFunctions.getZones(GetZonesArgs.builder()
            .availableResourceCreation("Instance")
            .build());
        final var defaultGetInstanceTypes = EcsFunctions.getInstanceTypes(GetInstanceTypesArgs.builder()
            .instanceTypeFamily("ecs.c6")
            .build());
        var defaultElasticityAssurance = new ElasticityAssurance("defaultElasticityAssurance", ElasticityAssuranceArgs.builder()
            .instanceAmount(1)
            .description("before")
            .zoneIds(defaultGetZones.applyValue(getZonesResult -> getZonesResult.zones()[2].id()))
            .privatePoolOptionsName("test_before")
            .period(1)
            .privatePoolOptionsMatchCriteria("Open")
            .instanceType(defaultGetInstanceTypes.applyValue(getInstanceTypesResult -> getInstanceTypesResult.instanceTypes()[0].id()))
            .periodUnit("Month")
            .assuranceTimes("Unlimited")
            .resourceGroupId(default_.ids()[0])
            .build());
    }
}

resources:
  defaultElasticityAssurance:
    type: alicloud:ecs:ElasticityAssurance
    name: default
    properties:
      instanceAmount: 1
      description: before
      zoneIds:
        - ${defaultGetZones.zones[2].id}
      privatePoolOptionsName: test_before
      period: 1
      privatePoolOptionsMatchCriteria: Open
      instanceType: ${defaultGetInstanceTypes.instanceTypes[0].id}
      periodUnit: Month
      assuranceTimes: Unlimited
      resourceGroupId: ${default.ids[0]}
variables:
  default:
    fn::invoke:
      function: alicloud:resourcemanager:getResourceGroups
      arguments:
        status: OK
  defaultGetZones:
    fn::invoke:
      function: alicloud:getZones
      arguments:
        availableResourceCreation: Instance
  defaultGetInstanceTypes:
    fn::invoke:
      function: alicloud:ecs:getInstanceTypes
      arguments:
        instanceTypeFamily: ecs.c6

$ pulumi import alicloud:ecs/elasticityAssurance:ElasticityAssurance example <id>