pulumi-alicloud-kotlin/com.pulumi.alicloud.ecs.kotlin/ElasticityAssurance

ElasticityAssurance

class ElasticityAssurance : KotlinCustomResource

Provides a Ecs Elasticity Assurance resource. For information about Ecs Elasticity Assurance and how to use it, see What is Elasticity Assurance.

NOTE: Available in v1.196.0+.

Example Usage

Basic Usage

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]),
});
Content copied to clipboard
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])
Content copied to clipboard
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])),
    });
});
Content copied to clipboard
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
	})
}
Content copied to clipboard
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());
    }
}
Content copied to clipboard
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
Content copied to clipboard

Import

Ecs Elasticity Assurance can be imported using the id, e.g.

$ pulumi import alicloud:ecs/elasticityAssurance:ElasticityAssurance example <id>
Content copied to clipboard

Properties

Link copied to clipboard
val assuranceTimes: Output<String>

The total number of times that the elasticity assurance can be applied. Set the value to Unlimited. This value indicates that the elasticity assurance can be applied an unlimited number of times within its effective duration. Default value: Unlimited.

Link copied to clipboard
val description: Output<String>?

Description of flexible guarantee service.

Link copied to clipboard
val elasticityAssuranceId: Output<String>

The first ID of the resource

Link copied to clipboard
val endTime: Output<String>

Flexible guarantee service failure time.

Link copied to clipboard
val id: Output<String>
Link copied to clipboard
val instanceAmount: Output<Int>

The total number of instances for which to reserve the capacity of an instance type. Valid values: 1 to 1000.

Link copied to clipboard
val instanceChargeType: Output<String>

The billing method of the instance. Possible value: PostPaid. Currently, only pay-as-you-go is supported.

Link copied to clipboard
val instanceType: Output<String>

Instance type. Currently, only one instance type is supported.

Link copied to clipboard
val period: Output<Int>?

Length of purchase. The unit of duration is determined by the 'period_unit' parameter. Default value: 1.

Link copied to clipboard
val periodUnit: Output<String>?

Duration unit. Value range:-Month: Month-Year: YearDefault value: Year

Link copied to clipboard
val privatePoolOptionsMatchCriteria: Output<String>

The matching mode of flexible guarantee service. Possible values:-Open: flexible guarantee service for Open mode.-Target: specifies the flexible guarantee service of the mode.

Link copied to clipboard
val privatePoolOptionsName: Output<String>

The name of the flexible protection service.

Link copied to clipboard
val pulumiChildResources: Set<KotlinResource>
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
val resourceGroupId: Output<String>?

The ID of the resource group.

Link copied to clipboard
val startTime: Output<String>

Flexible guarantee service effective time.

Link copied to clipboard
val startTimeType: Output<String>

Flexible guarantee effective way. Possible values:-Now: Effective immediately.-Later: the specified time takes effect.

Link copied to clipboard
val status: Output<String>

The status of flexible guarantee services. Possible values:-Preparing: in preparation.-Prepared: to take effect.-Active: in effect.-Released: Released.

Link copied to clipboard
val tags: Output<Map<String, String>>?

The tag key-value pair information bound by the elastic guarantee service.

Link copied to clipboard
val urn: Output<String>
Link copied to clipboard
val usedAssuranceTimes: Output<Int>

This parameter is not yet available.

Link copied to clipboard
val zoneIds: Output<List<String>>

The zone ID of the region to which the elastic Protection Service belongs. Currently, only the creation of flexible protection services in one available area is supported.