alicloud.sae.ApplicationScalingRule

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

return await Deployment.RunAsync(() => 
{
    var config = new Config();
    var name = config.Get("name") ?? "tf-example";
    var defaultRegions = AliCloud.GetRegions.Invoke(new()
    {
        Current = true,
    });

    var defaultRandomInteger = new Random.RandomInteger("defaultRandomInteger", new()
    {
        Max = 99999,
        Min = 10000,
    });

    var defaultZones = AliCloud.GetZones.Invoke(new()
    {
        AvailableResourceCreation = "VSwitch",
    });

    var defaultNetwork = new AliCloud.Vpc.Network("defaultNetwork", new()
    {
        VpcName = name,
        CidrBlock = "10.4.0.0/16",
    });

    var defaultSwitch = new AliCloud.Vpc.Switch("defaultSwitch", new()
    {
        VswitchName = name,
        CidrBlock = "10.4.0.0/24",
        VpcId = defaultNetwork.Id,
        ZoneId = defaultZones.Apply(getZonesResult => getZonesResult.Zones[0]?.Id),
    });

    var defaultSecurityGroup = new AliCloud.Ecs.SecurityGroup("defaultSecurityGroup", new()
    {
        VpcId = defaultNetwork.Id,
    });

    var defaultNamespace = new AliCloud.Sae.Namespace("defaultNamespace", new()
    {
        NamespaceId = Output.Tuple(defaultRegions, defaultRandomInteger.Result).Apply(values =>
        {
            var defaultRegions = values.Item1;
            var result = values.Item2;
            return $"{defaultRegions.Apply(getRegionsResult => getRegionsResult.Regions[0]?.Id)}:example{result}";
        }),
        NamespaceName = name,
        NamespaceDescription = name,
        EnableMicroRegistration = false,
    });

    var defaultApplication = new AliCloud.Sae.Application("defaultApplication", new()
    {
        AppDescription = name,
        AppName = name,
        NamespaceId = defaultNamespace.Id,
        ImageUrl = $"registry-vpc.{defaultRegions.Apply(getRegionsResult => getRegionsResult.Regions[0]?.Id)}.aliyuncs.com/sae-demo-image/consumer:1.0",
        PackageType = "Image",
        SecurityGroupId = defaultSecurityGroup.Id,
        VpcId = defaultNetwork.Id,
        VswitchId = defaultSwitch.Id,
        Timezone = "Asia/Beijing",
        Replicas = 5,
        Cpu = 500,
        Memory = 2048,
    });

    var defaultApplicationScalingRule = new AliCloud.Sae.ApplicationScalingRule("defaultApplicationScalingRule", new()
    {
        AppId = defaultApplication.Id,
        ScalingRuleName = name,
        ScalingRuleEnable = true,
        ScalingRuleType = "mix",
        MinReadyInstances = 3,
        MinReadyInstanceRatio = -1,
        ScalingRuleTimer = new AliCloud.Sae.Inputs.ApplicationScalingRuleScalingRuleTimerArgs
        {
            Period = "* * *",
            Schedules = new[]
            {
                new AliCloud.Sae.Inputs.ApplicationScalingRuleScalingRuleTimerScheduleArgs
                {
                    AtTime = "08:00",
                    MaxReplicas = 10,
                    MinReplicas = 3,
                },
                new AliCloud.Sae.Inputs.ApplicationScalingRuleScalingRuleTimerScheduleArgs
                {
                    AtTime = "20:00",
                    MaxReplicas = 50,
                    MinReplicas = 3,
                },
            },
        },
        ScalingRuleMetric = new AliCloud.Sae.Inputs.ApplicationScalingRuleScalingRuleMetricArgs
        {
            MaxReplicas = 50,
            MinReplicas = 3,
            Metrics = new[]
            {
                new AliCloud.Sae.Inputs.ApplicationScalingRuleScalingRuleMetricMetricArgs
                {
                    MetricType = "CPU",
                    MetricTargetAverageUtilization = 20,
                },
                new AliCloud.Sae.Inputs.ApplicationScalingRuleScalingRuleMetricMetricArgs
                {
                    MetricType = "MEMORY",
                    MetricTargetAverageUtilization = 30,
                },
                new AliCloud.Sae.Inputs.ApplicationScalingRuleScalingRuleMetricMetricArgs
                {
                    MetricType = "tcpActiveConn",
                    MetricTargetAverageUtilization = 20,
                },
            },
            ScaleUpRules = new AliCloud.Sae.Inputs.ApplicationScalingRuleScalingRuleMetricScaleUpRulesArgs
            {
                Step = 10,
                Disabled = false,
                StabilizationWindowSeconds = 0,
            },
            ScaleDownRules = new AliCloud.Sae.Inputs.ApplicationScalingRuleScalingRuleMetricScaleDownRulesArgs
            {
                Step = 10,
                Disabled = false,
                StabilizationWindowSeconds = 10,
            },
        },
    });

});

package main

import (
	"fmt"

	"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/sae"
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/vpc"
	"github.com/pulumi/pulumi-random/sdk/v4/go/random"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi/config"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		cfg := config.New(ctx, "")
		name := "tf-example"
		if param := cfg.Get("name"); param != "" {
			name = param
		}
		defaultRegions, err := alicloud.GetRegions(ctx, &alicloud.GetRegionsArgs{
			Current: pulumi.BoolRef(true),
		}, nil)
		if err != nil {
			return err
		}
		defaultRandomInteger, err := random.NewRandomInteger(ctx, "defaultRandomInteger", &random.RandomIntegerArgs{
			Max: pulumi.Int(99999),
			Min: pulumi.Int(10000),
		})
		if err != nil {
			return err
		}
		defaultZones, err := alicloud.GetZones(ctx, &alicloud.GetZonesArgs{
			AvailableResourceCreation: pulumi.StringRef("VSwitch"),
		}, nil)
		if err != nil {
			return err
		}
		defaultNetwork, err := vpc.NewNetwork(ctx, "defaultNetwork", &vpc.NetworkArgs{
			VpcName:   pulumi.String(name),
			CidrBlock: pulumi.String("10.4.0.0/16"),
		})
		if err != nil {
			return err
		}
		defaultSwitch, err := vpc.NewSwitch(ctx, "defaultSwitch", &vpc.SwitchArgs{
			VswitchName: pulumi.String(name),
			CidrBlock:   pulumi.String("10.4.0.0/24"),
			VpcId:       defaultNetwork.ID(),
			ZoneId:      *pulumi.String(defaultZones.Zones[0].Id),
		})
		if err != nil {
			return err
		}
		defaultSecurityGroup, err := ecs.NewSecurityGroup(ctx, "defaultSecurityGroup", &ecs.SecurityGroupArgs{
			VpcId: defaultNetwork.ID(),
		})
		if err != nil {
			return err
		}
		defaultNamespace, err := sae.NewNamespace(ctx, "defaultNamespace", &sae.NamespaceArgs{
			NamespaceId: defaultRandomInteger.Result.ApplyT(func(result int) (string, error) {
				return fmt.Sprintf("%v:example%v", defaultRegions.Regions[0].Id, result), nil
			}).(pulumi.StringOutput),
			NamespaceName:           pulumi.String(name),
			NamespaceDescription:    pulumi.String(name),
			EnableMicroRegistration: pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		defaultApplication, err := sae.NewApplication(ctx, "defaultApplication", &sae.ApplicationArgs{
			AppDescription:  pulumi.String(name),
			AppName:         pulumi.String(name),
			NamespaceId:     defaultNamespace.ID(),
			ImageUrl:        pulumi.String(fmt.Sprintf("registry-vpc.%v.aliyuncs.com/sae-demo-image/consumer:1.0", defaultRegions.Regions[0].Id)),
			PackageType:     pulumi.String("Image"),
			SecurityGroupId: defaultSecurityGroup.ID(),
			VpcId:           defaultNetwork.ID(),
			VswitchId:       defaultSwitch.ID(),
			Timezone:        pulumi.String("Asia/Beijing"),
			Replicas:        pulumi.Int(5),
			Cpu:             pulumi.Int(500),
			Memory:          pulumi.Int(2048),
		})
		if err != nil {
			return err
		}
		_, err = sae.NewApplicationScalingRule(ctx, "defaultApplicationScalingRule", &sae.ApplicationScalingRuleArgs{
			AppId:                 defaultApplication.ID(),
			ScalingRuleName:       pulumi.String(name),
			ScalingRuleEnable:     pulumi.Bool(true),
			ScalingRuleType:       pulumi.String("mix"),
			MinReadyInstances:     pulumi.Int(3),
			MinReadyInstanceRatio: pulumi.Int(-1),
			ScalingRuleTimer: &sae.ApplicationScalingRuleScalingRuleTimerArgs{
				Period: pulumi.String("* * *"),
				Schedules: sae.ApplicationScalingRuleScalingRuleTimerScheduleArray{
					&sae.ApplicationScalingRuleScalingRuleTimerScheduleArgs{
						AtTime:      pulumi.String("08:00"),
						MaxReplicas: pulumi.Int(10),
						MinReplicas: pulumi.Int(3),
					},
					&sae.ApplicationScalingRuleScalingRuleTimerScheduleArgs{
						AtTime:      pulumi.String("20:00"),
						MaxReplicas: pulumi.Int(50),
						MinReplicas: pulumi.Int(3),
					},
				},
			},
			ScalingRuleMetric: &sae.ApplicationScalingRuleScalingRuleMetricArgs{
				MaxReplicas: pulumi.Int(50),
				MinReplicas: pulumi.Int(3),
				Metrics: sae.ApplicationScalingRuleScalingRuleMetricMetricArray{
					&sae.ApplicationScalingRuleScalingRuleMetricMetricArgs{
						MetricType:                     pulumi.String("CPU"),
						MetricTargetAverageUtilization: pulumi.Int(20),
					},
					&sae.ApplicationScalingRuleScalingRuleMetricMetricArgs{
						MetricType:                     pulumi.String("MEMORY"),
						MetricTargetAverageUtilization: pulumi.Int(30),
					},
					&sae.ApplicationScalingRuleScalingRuleMetricMetricArgs{
						MetricType:                     pulumi.String("tcpActiveConn"),
						MetricTargetAverageUtilization: pulumi.Int(20),
					},
				},
				ScaleUpRules: &sae.ApplicationScalingRuleScalingRuleMetricScaleUpRulesArgs{
					Step:                       pulumi.Int(10),
					Disabled:                   pulumi.Bool(false),
					StabilizationWindowSeconds: pulumi.Int(0),
				},
				ScaleDownRules: &sae.ApplicationScalingRuleScalingRuleMetricScaleDownRulesArgs{
					Step:                       pulumi.Int(10),
					Disabled:                   pulumi.Bool(false),
					StabilizationWindowSeconds: pulumi.Int(10),
				},
			},
		})
		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.AlicloudFunctions;
import com.pulumi.alicloud.inputs.GetRegionsArgs;
import com.pulumi.random.RandomInteger;
import com.pulumi.random.RandomIntegerArgs;
import com.pulumi.alicloud.inputs.GetZonesArgs;
import com.pulumi.alicloud.vpc.Network;
import com.pulumi.alicloud.vpc.NetworkArgs;
import com.pulumi.alicloud.vpc.Switch;
import com.pulumi.alicloud.vpc.SwitchArgs;
import com.pulumi.alicloud.ecs.SecurityGroup;
import com.pulumi.alicloud.ecs.SecurityGroupArgs;
import com.pulumi.alicloud.sae.Namespace;
import com.pulumi.alicloud.sae.NamespaceArgs;
import com.pulumi.alicloud.sae.Application;
import com.pulumi.alicloud.sae.ApplicationArgs;
import com.pulumi.alicloud.sae.ApplicationScalingRule;
import com.pulumi.alicloud.sae.ApplicationScalingRuleArgs;
import com.pulumi.alicloud.sae.inputs.ApplicationScalingRuleScalingRuleTimerArgs;
import com.pulumi.alicloud.sae.inputs.ApplicationScalingRuleScalingRuleMetricArgs;
import com.pulumi.alicloud.sae.inputs.ApplicationScalingRuleScalingRuleMetricScaleUpRulesArgs;
import com.pulumi.alicloud.sae.inputs.ApplicationScalingRuleScalingRuleMetricScaleDownRulesArgs;
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 config = ctx.config();
        final var name = config.get("name").orElse("tf-example");
        final var defaultRegions = AlicloudFunctions.getRegions(GetRegionsArgs.builder()
            .current(true)
            .build());

        var defaultRandomInteger = new RandomInteger("defaultRandomInteger", RandomIntegerArgs.builder()        
            .max(99999)
            .min(10000)
            .build());

        final var defaultZones = AlicloudFunctions.getZones(GetZonesArgs.builder()
            .availableResourceCreation("VSwitch")
            .build());

        var defaultNetwork = new Network("defaultNetwork", NetworkArgs.builder()        
            .vpcName(name)
            .cidrBlock("10.4.0.0/16")
            .build());

        var defaultSwitch = new Switch("defaultSwitch", SwitchArgs.builder()        
            .vswitchName(name)
            .cidrBlock("10.4.0.0/24")
            .vpcId(defaultNetwork.id())
            .zoneId(defaultZones.applyValue(getZonesResult -> getZonesResult.zones()[0].id()))
            .build());

        var defaultSecurityGroup = new SecurityGroup("defaultSecurityGroup", SecurityGroupArgs.builder()        
            .vpcId(defaultNetwork.id())
            .build());

        var defaultNamespace = new Namespace("defaultNamespace", NamespaceArgs.builder()        
            .namespaceId(defaultRandomInteger.result().applyValue(result -> String.format("%s:example%s", defaultRegions.applyValue(getRegionsResult -> getRegionsResult.regions()[0].id()),result)))
            .namespaceName(name)
            .namespaceDescription(name)
            .enableMicroRegistration(false)
            .build());

        var defaultApplication = new Application("defaultApplication", ApplicationArgs.builder()        
            .appDescription(name)
            .appName(name)
            .namespaceId(defaultNamespace.id())
            .imageUrl(String.format("registry-vpc.%s.aliyuncs.com/sae-demo-image/consumer:1.0", defaultRegions.applyValue(getRegionsResult -> getRegionsResult.regions()[0].id())))
            .packageType("Image")
            .securityGroupId(defaultSecurityGroup.id())
            .vpcId(defaultNetwork.id())
            .vswitchId(defaultSwitch.id())
            .timezone("Asia/Beijing")
            .replicas("5")
            .cpu("500")
            .memory("2048")
            .build());

        var defaultApplicationScalingRule = new ApplicationScalingRule("defaultApplicationScalingRule", ApplicationScalingRuleArgs.builder()        
            .appId(defaultApplication.id())
            .scalingRuleName(name)
            .scalingRuleEnable(true)
            .scalingRuleType("mix")
            .minReadyInstances("3")
            .minReadyInstanceRatio("-1")
            .scalingRuleTimer(ApplicationScalingRuleScalingRuleTimerArgs.builder()
                .period("* * *")
                .schedules(                
                    ApplicationScalingRuleScalingRuleTimerScheduleArgs.builder()
                        .atTime("08:00")
                        .maxReplicas(10)
                        .minReplicas(3)
                        .build(),
                    ApplicationScalingRuleScalingRuleTimerScheduleArgs.builder()
                        .atTime("20:00")
                        .maxReplicas(50)
                        .minReplicas(3)
                        .build())
                .build())
            .scalingRuleMetric(ApplicationScalingRuleScalingRuleMetricArgs.builder()
                .maxReplicas(50)
                .minReplicas(3)
                .metrics(                
                    ApplicationScalingRuleScalingRuleMetricMetricArgs.builder()
                        .metricType("CPU")
                        .metricTargetAverageUtilization(20)
                        .build(),
                    ApplicationScalingRuleScalingRuleMetricMetricArgs.builder()
                        .metricType("MEMORY")
                        .metricTargetAverageUtilization(30)
                        .build(),
                    ApplicationScalingRuleScalingRuleMetricMetricArgs.builder()
                        .metricType("tcpActiveConn")
                        .metricTargetAverageUtilization(20)
                        .build())
                .scaleUpRules(ApplicationScalingRuleScalingRuleMetricScaleUpRulesArgs.builder()
                    .step(10)
                    .disabled(false)
                    .stabilizationWindowSeconds(0)
                    .build())
                .scaleDownRules(ApplicationScalingRuleScalingRuleMetricScaleDownRulesArgs.builder()
                    .step(10)
                    .disabled(false)
                    .stabilizationWindowSeconds(10)
                    .build())
                .build())
            .build());

    }
}

import pulumi
import pulumi_alicloud as alicloud
import pulumi_random as random

config = pulumi.Config()
name = config.get("name")
if name is None:
    name = "tf-example"
default_regions = alicloud.get_regions(current=True)
default_random_integer = random.RandomInteger("defaultRandomInteger",
    max=99999,
    min=10000)
default_zones = alicloud.get_zones(available_resource_creation="VSwitch")
default_network = alicloud.vpc.Network("defaultNetwork",
    vpc_name=name,
    cidr_block="10.4.0.0/16")
default_switch = alicloud.vpc.Switch("defaultSwitch",
    vswitch_name=name,
    cidr_block="10.4.0.0/24",
    vpc_id=default_network.id,
    zone_id=default_zones.zones[0].id)
default_security_group = alicloud.ecs.SecurityGroup("defaultSecurityGroup", vpc_id=default_network.id)
default_namespace = alicloud.sae.Namespace("defaultNamespace",
    namespace_id=default_random_integer.result.apply(lambda result: f"{default_regions.regions[0].id}:example{result}"),
    namespace_name=name,
    namespace_description=name,
    enable_micro_registration=False)
default_application = alicloud.sae.Application("defaultApplication",
    app_description=name,
    app_name=name,
    namespace_id=default_namespace.id,
    image_url=f"registry-vpc.{default_regions.regions[0].id}.aliyuncs.com/sae-demo-image/consumer:1.0",
    package_type="Image",
    security_group_id=default_security_group.id,
    vpc_id=default_network.id,
    vswitch_id=default_switch.id,
    timezone="Asia/Beijing",
    replicas=5,
    cpu=500,
    memory=2048)
default_application_scaling_rule = alicloud.sae.ApplicationScalingRule("defaultApplicationScalingRule",
    app_id=default_application.id,
    scaling_rule_name=name,
    scaling_rule_enable=True,
    scaling_rule_type="mix",
    min_ready_instances=3,
    min_ready_instance_ratio=-1,
    scaling_rule_timer=alicloud.sae.ApplicationScalingRuleScalingRuleTimerArgs(
        period="* * *",
        schedules=[
            alicloud.sae.ApplicationScalingRuleScalingRuleTimerScheduleArgs(
                at_time="08:00",
                max_replicas=10,
                min_replicas=3,
            ),
            alicloud.sae.ApplicationScalingRuleScalingRuleTimerScheduleArgs(
                at_time="20:00",
                max_replicas=50,
                min_replicas=3,
            ),
        ],
    ),
    scaling_rule_metric=alicloud.sae.ApplicationScalingRuleScalingRuleMetricArgs(
        max_replicas=50,
        min_replicas=3,
        metrics=[
            alicloud.sae.ApplicationScalingRuleScalingRuleMetricMetricArgs(
                metric_type="CPU",
                metric_target_average_utilization=20,
            ),
            alicloud.sae.ApplicationScalingRuleScalingRuleMetricMetricArgs(
                metric_type="MEMORY",
                metric_target_average_utilization=30,
            ),
            alicloud.sae.ApplicationScalingRuleScalingRuleMetricMetricArgs(
                metric_type="tcpActiveConn",
                metric_target_average_utilization=20,
            ),
        ],
        scale_up_rules=alicloud.sae.ApplicationScalingRuleScalingRuleMetricScaleUpRulesArgs(
            step=10,
            disabled=False,
            stabilization_window_seconds=0,
        ),
        scale_down_rules=alicloud.sae.ApplicationScalingRuleScalingRuleMetricScaleDownRulesArgs(
            step=10,
            disabled=False,
            stabilization_window_seconds=10,
        ),
    ))

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

const config = new pulumi.Config();
const name = config.get("name") || "tf-example";
const defaultRegions = alicloud.getRegions({
    current: true,
});
const defaultRandomInteger = new random.RandomInteger("defaultRandomInteger", {
    max: 99999,
    min: 10000,
});
const defaultZones = alicloud.getZones({
    availableResourceCreation: "VSwitch",
});
const defaultNetwork = new alicloud.vpc.Network("defaultNetwork", {
    vpcName: name,
    cidrBlock: "10.4.0.0/16",
});
const defaultSwitch = new alicloud.vpc.Switch("defaultSwitch", {
    vswitchName: name,
    cidrBlock: "10.4.0.0/24",
    vpcId: defaultNetwork.id,
    zoneId: defaultZones.then(defaultZones => defaultZones.zones?.[0]?.id),
});
const defaultSecurityGroup = new alicloud.ecs.SecurityGroup("defaultSecurityGroup", {vpcId: defaultNetwork.id});
const defaultNamespace = new alicloud.sae.Namespace("defaultNamespace", {
    namespaceId: pulumi.all([defaultRegions, defaultRandomInteger.result]).apply(([defaultRegions, result]) => `${defaultRegions.regions?.[0]?.id}:example${result}`),
    namespaceName: name,
    namespaceDescription: name,
    enableMicroRegistration: false,
});
const defaultApplication = new alicloud.sae.Application("defaultApplication", {
    appDescription: name,
    appName: name,
    namespaceId: defaultNamespace.id,
    imageUrl: defaultRegions.then(defaultRegions => `registry-vpc.${defaultRegions.regions?.[0]?.id}.aliyuncs.com/sae-demo-image/consumer:1.0`),
    packageType: "Image",
    securityGroupId: defaultSecurityGroup.id,
    vpcId: defaultNetwork.id,
    vswitchId: defaultSwitch.id,
    timezone: "Asia/Beijing",
    replicas: 5,
    cpu: 500,
    memory: 2048,
});
const defaultApplicationScalingRule = new alicloud.sae.ApplicationScalingRule("defaultApplicationScalingRule", {
    appId: defaultApplication.id,
    scalingRuleName: name,
    scalingRuleEnable: true,
    scalingRuleType: "mix",
    minReadyInstances: 3,
    minReadyInstanceRatio: -1,
    scalingRuleTimer: {
        period: "* * *",
        schedules: [
            {
                atTime: "08:00",
                maxReplicas: 10,
                minReplicas: 3,
            },
            {
                atTime: "20:00",
                maxReplicas: 50,
                minReplicas: 3,
            },
        ],
    },
    scalingRuleMetric: {
        maxReplicas: 50,
        minReplicas: 3,
        metrics: [
            {
                metricType: "CPU",
                metricTargetAverageUtilization: 20,
            },
            {
                metricType: "MEMORY",
                metricTargetAverageUtilization: 30,
            },
            {
                metricType: "tcpActiveConn",
                metricTargetAverageUtilization: 20,
            },
        ],
        scaleUpRules: {
            step: 10,
            disabled: false,
            stabilizationWindowSeconds: 0,
        },
        scaleDownRules: {
            step: 10,
            disabled: false,
            stabilizationWindowSeconds: 10,
        },
    },
});

configuration:
  name:
    type: string
    default: tf-example
resources:
  defaultRandomInteger:
    type: random:RandomInteger
    properties:
      max: 99999
      min: 10000
  defaultNetwork:
    type: alicloud:vpc:Network
    properties:
      vpcName: ${name}
      cidrBlock: 10.4.0.0/16
  defaultSwitch:
    type: alicloud:vpc:Switch
    properties:
      vswitchName: ${name}
      cidrBlock: 10.4.0.0/24
      vpcId: ${defaultNetwork.id}
      zoneId: ${defaultZones.zones[0].id}
  defaultSecurityGroup:
    type: alicloud:ecs:SecurityGroup
    properties:
      vpcId: ${defaultNetwork.id}
  defaultNamespace:
    type: alicloud:sae:Namespace
    properties:
      namespaceId: ${defaultRegions.regions[0].id}:example${defaultRandomInteger.result}
      namespaceName: ${name}
      namespaceDescription: ${name}
      enableMicroRegistration: false
  defaultApplication:
    type: alicloud:sae:Application
    properties:
      appDescription: ${name}
      appName: ${name}
      namespaceId: ${defaultNamespace.id}
      imageUrl: registry-vpc.${defaultRegions.regions[0].id}.aliyuncs.com/sae-demo-image/consumer:1.0
      packageType: Image
      securityGroupId: ${defaultSecurityGroup.id}
      vpcId: ${defaultNetwork.id}
      vswitchId: ${defaultSwitch.id}
      timezone: Asia/Beijing
      replicas: '5'
      cpu: '500'
      memory: '2048'
  defaultApplicationScalingRule:
    type: alicloud:sae:ApplicationScalingRule
    properties:
      appId: ${defaultApplication.id}
      scalingRuleName: ${name}
      scalingRuleEnable: true
      scalingRuleType: mix
      minReadyInstances: '3'
      minReadyInstanceRatio: '-1'
      scalingRuleTimer:
        period: '* * *'
        schedules:
          - atTime: 08:00
            maxReplicas: 10
            minReplicas: 3
          - atTime: 20:00
            maxReplicas: 50
            minReplicas: 3
      scalingRuleMetric:
        maxReplicas: 50
        minReplicas: 3
        metrics:
          - metricType: CPU
            metricTargetAverageUtilization: 20
          - metricType: MEMORY
            metricTargetAverageUtilization: 30
          - metricType: tcpActiveConn
            metricTargetAverageUtilization: 20
        scaleUpRules:
          step: 10
          disabled: false
          stabilizationWindowSeconds: 0
        scaleDownRules:
          step: 10
          disabled: false
          stabilizationWindowSeconds: 10
variables:
  defaultRegions:
    fn::invoke:
      Function: alicloud:getRegions
      Arguments:
        current: true
  defaultZones:
    fn::invoke:
      Function: alicloud:getZones
      Arguments:
        availableResourceCreation: VSwitch