alicloud.ess.getEciScalingConfigurations

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") || "terraform-example";
const defaultInteger = new random.index.Integer("default", {
    min: 10000,
    max: 99999,
});
const myName = `${name}-${defaultInteger.result}`;
const _default = alicloud.getZones({
    availableDiskCategory: "cloud_efficiency",
    availableResourceCreation: "VSwitch",
});
const defaultNetwork = new alicloud.vpc.Network("default", {
    vpcName: myName,
    cidrBlock: "172.16.0.0/16",
});
const defaultSwitch = new alicloud.vpc.Switch("default", {
    vpcId: defaultNetwork.id,
    cidrBlock: "172.16.0.0/24",
    zoneId: _default.then(_default => _default.zones?.[0]?.id),
    vswitchName: myName,
});
const defaultSecurityGroup = new alicloud.ecs.SecurityGroup("default", {
    securityGroupName: myName,
    vpcId: defaultNetwork.id,
});
const defaultScalingGroup = new alicloud.ess.ScalingGroup("default", {
    minSize: 0,
    maxSize: 1,
    scalingGroupName: myName,
    removalPolicies: [
        "OldestInstance",
        "NewestInstance",
    ],
    vswitchIds: [defaultSwitch.id],
    groupType: "ECI",
});
const defaultEciScalingConfiguration = new alicloud.ess.EciScalingConfiguration("default", {
    scalingGroupId: defaultScalingGroup.id,
    cpu: 2,
    memory: 4,
    securityGroupId: defaultSecurityGroup.id,
    forceDelete: true,
    active: true,
    containerGroupName: myName,
    containers: [{
        name: "container-1",
        image: "registry-vpc.cn-hangzhou.aliyuncs.com/eci_open/alpine:3.5",
    }],
});
const defaultGetEciScalingConfigurations = alicloud.ess.getEciScalingConfigurationsOutput({
    scalingGroupId: defaultScalingGroup.id,
    ids: [defaultEciScalingConfiguration.id],
    nameRegex: name,
});
export const firstScalingConfiguration = defaultGetEciScalingConfigurations.apply(defaultGetEciScalingConfigurations => defaultGetEciScalingConfigurations.configurations?.[0]?.id);

import pulumi
import pulumi_alicloud as alicloud
import pulumi_random as random

config = pulumi.Config()
name = config.get("name")
if name is None:
    name = "terraform-example"
default_integer = random.Integer("default",
    min=10000,
    max=99999)
my_name = f"{name}-{default_integer['result']}"
default = alicloud.get_zones(available_disk_category="cloud_efficiency",
    available_resource_creation="VSwitch")
default_network = alicloud.vpc.Network("default",
    vpc_name=my_name,
    cidr_block="172.16.0.0/16")
default_switch = alicloud.vpc.Switch("default",
    vpc_id=default_network.id,
    cidr_block="172.16.0.0/24",
    zone_id=default.zones[0].id,
    vswitch_name=my_name)
default_security_group = alicloud.ecs.SecurityGroup("default",
    security_group_name=my_name,
    vpc_id=default_network.id)
default_scaling_group = alicloud.ess.ScalingGroup("default",
    min_size=0,
    max_size=1,
    scaling_group_name=my_name,
    removal_policies=[
        "OldestInstance",
        "NewestInstance",
    ],
    vswitch_ids=[default_switch.id],
    group_type="ECI")
default_eci_scaling_configuration = alicloud.ess.EciScalingConfiguration("default",
    scaling_group_id=default_scaling_group.id,
    cpu=float(2),
    memory=float(4),
    security_group_id=default_security_group.id,
    force_delete=True,
    active=True,
    container_group_name=my_name,
    containers=[{
        "name": "container-1",
        "image": "registry-vpc.cn-hangzhou.aliyuncs.com/eci_open/alpine:3.5",
    }])
default_get_eci_scaling_configurations = alicloud.ess.get_eci_scaling_configurations_output(scaling_group_id=default_scaling_group.id,
    ids=[default_eci_scaling_configuration.id],
    name_regex=name)
pulumi.export("firstScalingConfiguration", default_get_eci_scaling_configurations.configurations[0].id)

package main

import (
	"fmt"

	"github.com/pulumi/pulumi-alicloud/sdk/v4/go/alicloud"
	"github.com/pulumi/pulumi-alicloud/sdk/v4/go/alicloud/ecs"
	"github.com/pulumi/pulumi-alicloud/sdk/v4/go/alicloud/ess"
	"github.com/pulumi/pulumi-alicloud/sdk/v4/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 := "terraform-example"
		if param := cfg.Get("name"); param != "" {
			name = param
		}
		defaultInteger, err := random.NewInteger(ctx, "default", &random.IntegerArgs{
			Min: 10000,
			Max: 99999,
		})
		if err != nil {
			return err
		}
		myName := fmt.Sprintf("%v-%v", name, defaultInteger.Result)
		_default, err := alicloud.GetZones(ctx, &alicloud.GetZonesArgs{
			AvailableDiskCategory:     pulumi.StringRef("cloud_efficiency"),
			AvailableResourceCreation: pulumi.StringRef("VSwitch"),
		}, nil)
		if err != nil {
			return err
		}
		defaultNetwork, err := vpc.NewNetwork(ctx, "default", &vpc.NetworkArgs{
			VpcName:   pulumi.String(myName),
			CidrBlock: pulumi.String("172.16.0.0/16"),
		})
		if err != nil {
			return err
		}
		defaultSwitch, err := vpc.NewSwitch(ctx, "default", &vpc.SwitchArgs{
			VpcId:       defaultNetwork.ID(),
			CidrBlock:   pulumi.String("172.16.0.0/24"),
			ZoneId:      pulumi.String(_default.Zones[0].Id),
			VswitchName: pulumi.String(myName),
		})
		if err != nil {
			return err
		}
		defaultSecurityGroup, err := ecs.NewSecurityGroup(ctx, "default", &ecs.SecurityGroupArgs{
			SecurityGroupName: pulumi.String(myName),
			VpcId:             defaultNetwork.ID(),
		})
		if err != nil {
			return err
		}
		defaultScalingGroup, err := ess.NewScalingGroup(ctx, "default", &ess.ScalingGroupArgs{
			MinSize:          pulumi.Int(0),
			MaxSize:          pulumi.Int(1),
			ScalingGroupName: pulumi.String(myName),
			RemovalPolicies: pulumi.StringArray{
				pulumi.String("OldestInstance"),
				pulumi.String("NewestInstance"),
			},
			VswitchIds: pulumi.StringArray{
				defaultSwitch.ID(),
			},
			GroupType: pulumi.String("ECI"),
		})
		if err != nil {
			return err
		}
		defaultEciScalingConfiguration, err := ess.NewEciScalingConfiguration(ctx, "default", &ess.EciScalingConfigurationArgs{
			ScalingGroupId:     defaultScalingGroup.ID(),
			Cpu:                pulumi.Float64(2),
			Memory:             pulumi.Float64(4),
			SecurityGroupId:    defaultSecurityGroup.ID(),
			ForceDelete:        pulumi.Bool(true),
			Active:             pulumi.Bool(true),
			ContainerGroupName: pulumi.String(myName),
			Containers: ess.EciScalingConfigurationContainerArray{
				&ess.EciScalingConfigurationContainerArgs{
					Name:  pulumi.String("container-1"),
					Image: pulumi.String("registry-vpc.cn-hangzhou.aliyuncs.com/eci_open/alpine:3.5"),
				},
			},
		})
		if err != nil {
			return err
		}
		defaultGetEciScalingConfigurations := ess.GetEciScalingConfigurationsOutput(ctx, ess.GetEciScalingConfigurationsOutputArgs{
			ScalingGroupId: defaultScalingGroup.ID(),
			Ids: pulumi.StringArray{
				defaultEciScalingConfiguration.ID(),
			},
			NameRegex: pulumi.String(name),
		}, nil)
		ctx.Export("firstScalingConfiguration", defaultGetEciScalingConfigurations.ApplyT(func(defaultGetEciScalingConfigurations ess.GetEciScalingConfigurationsResult) (*string, error) {
			return defaultGetEciScalingConfigurations.Configurations[0].Id, nil
		}).(pulumi.StringPtrOutput))
		return nil
	})
}

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") ?? "terraform-example";
    var defaultInteger = new Random.Integer("default", new()
    {
        Min = 10000,
        Max = 99999,
    });

    var myName = $"{name}-{defaultInteger.Result}";

    var @default = AliCloud.GetZones.Invoke(new()
    {
        AvailableDiskCategory = "cloud_efficiency",
        AvailableResourceCreation = "VSwitch",
    });

    var defaultNetwork = new AliCloud.Vpc.Network("default", new()
    {
        VpcName = myName,
        CidrBlock = "172.16.0.0/16",
    });

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

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

    var defaultScalingGroup = new AliCloud.Ess.ScalingGroup("default", new()
    {
        MinSize = 0,
        MaxSize = 1,
        ScalingGroupName = myName,
        RemovalPolicies = new[]
        {
            "OldestInstance",
            "NewestInstance",
        },
        VswitchIds = new[]
        {
            defaultSwitch.Id,
        },
        GroupType = "ECI",
    });

    var defaultEciScalingConfiguration = new AliCloud.Ess.EciScalingConfiguration("default", new()
    {
        ScalingGroupId = defaultScalingGroup.Id,
        Cpu = 2.0,
        Memory = 4.0,
        SecurityGroupId = defaultSecurityGroup.Id,
        ForceDelete = true,
        Active = true,
        ContainerGroupName = myName,
        Containers = new[]
        {
            new AliCloud.Ess.Inputs.EciScalingConfigurationContainerArgs
            {
                Name = "container-1",
                Image = "registry-vpc.cn-hangzhou.aliyuncs.com/eci_open/alpine:3.5",
            },
        },
    });

    var defaultGetEciScalingConfigurations = AliCloud.Ess.GetEciScalingConfigurations.Invoke(new()
    {
        ScalingGroupId = defaultScalingGroup.Id,
        Ids = new[]
        {
            defaultEciScalingConfiguration.Id,
        },
        NameRegex = name,
    });

    return new Dictionary<string, object?>
    {
        ["firstScalingConfiguration"] = defaultGetEciScalingConfigurations.Apply(getEciScalingConfigurationsResult => getEciScalingConfigurationsResult.Configurations[0]?.Id),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.random.Integer;
import com.pulumi.random.IntegerArgs;
import com.pulumi.alicloud.AlicloudFunctions;
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.ess.ScalingGroup;
import com.pulumi.alicloud.ess.ScalingGroupArgs;
import com.pulumi.alicloud.ess.EciScalingConfiguration;
import com.pulumi.alicloud.ess.EciScalingConfigurationArgs;
import com.pulumi.alicloud.ess.inputs.EciScalingConfigurationContainerArgs;
import com.pulumi.alicloud.ess.EssFunctions;
import com.pulumi.alicloud.ess.inputs.GetEciScalingConfigurationsArgs;
import java.util.ArrayList;
import java.util.Arrays;
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("terraform-example");
        var defaultInteger = new Integer("defaultInteger", IntegerArgs.builder()
            .min(10000)
            .max(99999)
            .build());

        final var myName = String.format("%s-%s", name,defaultInteger.get("result"));

        final var default = AlicloudFunctions.getZones(GetZonesArgs.builder()
            .availableDiskCategory("cloud_efficiency")
            .availableResourceCreation("VSwitch")
            .build());

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

        var defaultSwitch = new Switch("defaultSwitch", SwitchArgs.builder()
            .vpcId(defaultNetwork.id())
            .cidrBlock("172.16.0.0/24")
            .zoneId(default_.zones()[0].id())
            .vswitchName(myName)
            .build());

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

        var defaultScalingGroup = new ScalingGroup("defaultScalingGroup", ScalingGroupArgs.builder()
            .minSize(0)
            .maxSize(1)
            .scalingGroupName(myName)
            .removalPolicies(            
                "OldestInstance",
                "NewestInstance")
            .vswitchIds(defaultSwitch.id())
            .groupType("ECI")
            .build());

        var defaultEciScalingConfiguration = new EciScalingConfiguration("defaultEciScalingConfiguration", EciScalingConfigurationArgs.builder()
            .scalingGroupId(defaultScalingGroup.id())
            .cpu(2.0)
            .memory(4.0)
            .securityGroupId(defaultSecurityGroup.id())
            .forceDelete(true)
            .active(true)
            .containerGroupName(myName)
            .containers(EciScalingConfigurationContainerArgs.builder()
                .name("container-1")
                .image("registry-vpc.cn-hangzhou.aliyuncs.com/eci_open/alpine:3.5")
                .build())
            .build());

        final var defaultGetEciScalingConfigurations = EssFunctions.getEciScalingConfigurations(GetEciScalingConfigurationsArgs.builder()
            .scalingGroupId(defaultScalingGroup.id())
            .ids(defaultEciScalingConfiguration.id())
            .nameRegex(name)
            .build());

        ctx.export("firstScalingConfiguration", defaultGetEciScalingConfigurations.applyValue(_defaultGetEciScalingConfigurations -> _defaultGetEciScalingConfigurations.configurations().get(0).id()));
    }
}

configuration:
  name:
    type: string
    default: terraform-example
resources:
  defaultInteger:
    type: random:Integer
    name: default
    properties:
      min: 10000
      max: 99999
  defaultNetwork:
    type: alicloud:vpc:Network
    name: default
    properties:
      vpcName: ${myName}
      cidrBlock: 172.16.0.0/16
  defaultSwitch:
    type: alicloud:vpc:Switch
    name: default
    properties:
      vpcId: ${defaultNetwork.id}
      cidrBlock: 172.16.0.0/24
      zoneId: ${default.zones[0].id}
      vswitchName: ${myName}
  defaultSecurityGroup:
    type: alicloud:ecs:SecurityGroup
    name: default
    properties:
      securityGroupName: ${myName}
      vpcId: ${defaultNetwork.id}
  defaultScalingGroup:
    type: alicloud:ess:ScalingGroup
    name: default
    properties:
      minSize: 0
      maxSize: 1
      scalingGroupName: ${myName}
      removalPolicies:
        - OldestInstance
        - NewestInstance
      vswitchIds:
        - ${defaultSwitch.id}
      groupType: ECI
  defaultEciScalingConfiguration:
    type: alicloud:ess:EciScalingConfiguration
    name: default
    properties:
      scalingGroupId: ${defaultScalingGroup.id}
      cpu: 2
      memory: 4
      securityGroupId: ${defaultSecurityGroup.id}
      forceDelete: true
      active: true
      containerGroupName: ${myName}
      containers:
        - name: container-1
          image: registry-vpc.cn-hangzhou.aliyuncs.com/eci_open/alpine:3.5
variables:
  myName: ${name}-${defaultInteger.result}
  default:
    fn::invoke:
      function: alicloud:getZones
      arguments:
        availableDiskCategory: cloud_efficiency
        availableResourceCreation: VSwitch
  defaultGetEciScalingConfigurations:
    fn::invoke:
      function: alicloud:ess:getEciScalingConfigurations
      arguments:
        scalingGroupId: ${defaultScalingGroup.id}
        ids:
          - ${defaultEciScalingConfiguration.id}
        nameRegex: ${name}
outputs:
  firstScalingConfiguration: ${defaultGetEciScalingConfigurations.configurations[0].id}

terraform {
  required_providers {
    alicloud = {
      source = "pulumi/alicloud"
    }
    random = {
      source = "pulumi/random"
    }
  }
}

data "alicloud_zones" "default" {
  available_disk_category     = "cloud_efficiency"
  available_resource_creation = "VSwitch"
}
data "alicloud_ess_eci_scaling_configurations" "defaultGetEciScalingConfigurations" {
  scaling_group_id = alicloud_ess_scaling_group.default.id
  ids              = [alicloud_ess_eci_scaling_configuration.default.id]
  name_regex       = var.name
}

resource "random_integer" "default" {
  lifecycle {
    create_before_destroy = true
  }
  min = 10000
  max = 99999
}
resource "alicloud_vpc_network" "default" {
  lifecycle {
    create_before_destroy = true
  }
  vpc_name   = local.myName
  cidr_block = "172.16.0.0/16"
}
resource "alicloud_vpc_switch" "default" {
  lifecycle {
    create_before_destroy = true
  }
  vpc_id       = alicloud_vpc_network.default.id
  cidr_block   = "172.16.0.0/24"
  zone_id      = data.alicloud_zones.default.zones[0].id
  vswitch_name = local.myName
}
resource "alicloud_ecs_security_group" "default" {
  lifecycle {
    create_before_destroy = true
  }
  security_group_name = local.myName
  vpc_id              = alicloud_vpc_network.default.id
}
resource "alicloud_ess_scaling_group" "default" {
  lifecycle {
    create_before_destroy = true
  }
  min_size           = 0
  max_size           = 1
  scaling_group_name = local.myName
  removal_policies   = ["OldestInstance", "NewestInstance"]
  vswitch_ids        = [alicloud_vpc_switch.default.id]
  group_type         = "ECI"
}
resource "alicloud_ess_eci_scaling_configuration" "default" {
  lifecycle {
    create_before_destroy = true
  }
  scaling_group_id     = alicloud_ess_scaling_group.default.id
  cpu                  = 2
  memory               = 4
  security_group_id    = alicloud_ecs_security_group.default.id
  force_delete         = true
  active               = true
  container_group_name = local.myName
  containers {
    name  = "container-1"
    image = "registry-vpc.cn-hangzhou.aliyuncs.com/eci_open/alpine:3.5"
  }
}
variable "name" {
  type    = string
  default = "terraform-example"
}
locals {
  myName ="${var.name}-${random_integer.default.result}"
}
output "firstScalingConfiguration" {
  value = data.alicloud_ess_eci_scaling_configurations.defaultGetEciScalingConfigurations.configurations[0].id
}

function getEciScalingConfigurations(args: GetEciScalingConfigurationsArgs, opts?: InvokeOptions): Promise<GetEciScalingConfigurationsResult>
function getEciScalingConfigurationsOutput(args: GetEciScalingConfigurationsOutputArgs, opts?: InvokeOutputOptions): Output<GetEciScalingConfigurationsResult>

def get_eci_scaling_configurations(ids: Optional[Sequence[str]] = None,
                                   name_regex: Optional[str] = None,
                                   output_file: Optional[str] = None,
                                   scaling_group_id: Optional[str] = None,
                                   opts: Optional[InvokeOptions] = None) -> GetEciScalingConfigurationsResult
def get_eci_scaling_configurations_output(ids: pulumi.Input[Optional[Sequence[pulumi.Input[str]]]] = None,
                                   name_regex: pulumi.Input[Optional[str]] = None,
                                   output_file: pulumi.Input[Optional[str]] = None,
                                   scaling_group_id: pulumi.Input[Optional[str]] = None,
                                   opts: Optional[InvokeOutputOptions] = None) -> Output[GetEciScalingConfigurationsResult]

func GetEciScalingConfigurations(ctx *Context, args *GetEciScalingConfigurationsArgs, opts ...InvokeOption) (*GetEciScalingConfigurationsResult, error)
func GetEciScalingConfigurationsOutput(ctx *Context, args *GetEciScalingConfigurationsOutputArgs, opts ...InvokeOption) GetEciScalingConfigurationsResultOutput

public static class GetEciScalingConfigurations 
{
    public static Task<GetEciScalingConfigurationsResult> InvokeAsync(GetEciScalingConfigurationsArgs args, InvokeOptions? opts = null)
    public static Output<GetEciScalingConfigurationsResult> Invoke(GetEciScalingConfigurationsInvokeArgs args, InvokeOptions? opts = null)
    public static Output<GetEciScalingConfigurationsResult> Invoke(GetEciScalingConfigurationsInvokeArgs args, InvokeOutputOptions opts)
}

public static CompletableFuture<GetEciScalingConfigurationsResult> getEciScalingConfigurations(GetEciScalingConfigurationsArgs args, InvokeOptions options)
public static Output<GetEciScalingConfigurationsResult> getEciScalingConfigurations(GetEciScalingConfigurationsArgs args, InvokeOptions options)
public static Output<GetEciScalingConfigurationsResult> getEciScalingConfigurations(GetEciScalingConfigurationsArgs args, InvokeOutputOptions options)

fn::invoke:
  function: alicloud:ess/getEciScalingConfigurations:getEciScalingConfigurations
  arguments:
    # arguments dictionary

data "alicloud_ess_get_eci_scaling_configurations" "name" {
    # arguments
}