alicloud.arms.getAddonReleases

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

const config = new pulumi.Config();
const name = config.get("name") || "terraform-example";
const defaultInteger = new random.index.Integer("default", {
    min: 10000,
    max: 99999,
});
const enhanced = alicloud.vpc.getEnhancedNatAvailableZones({});
const vpc = new alicloud.vpc.Network("vpc", {
    description: "api-resource-test1-hz",
    cidrBlock: "192.168.0.0/16",
    vpcName: `${name}-${defaultInteger.result}`,
});
const vswitch = new alicloud.vpc.Switch("vswitch", {
    description: "api-resource-test1-hz",
    vpcId: vpc.id,
    vswitchName: `${name}-${defaultInteger.result}`,
    zoneId: enhanced.then(enhanced => enhanced.zones?.[0]?.zoneId),
    cidrBlock: vpc.cidrBlock.apply(cidrBlock => std.cidrsubnetOutput({
        input: cidrBlock,
        newbits: 8,
        netnum: 8,
    })).apply(invoke => invoke.result),
});
const defaultSnapshotPolicy = new alicloud.ecs.SnapshotPolicy("default", {
    name: `${name}-${defaultInteger.result}`,
    repeatWeekdays: [
        "1",
        "2",
        "3",
    ],
    retentionDays: -1,
    timePoints: [
        "1",
        "22",
        "23",
    ],
});
const _default = vswitch.zoneId.apply(zoneId => alicloud.ecs.getInstanceTypesOutput({
    availabilityZone: zoneId,
    cpuCoreCount: 2,
    memorySize: 4,
    kubernetesNodeRole: "Worker",
    instanceTypeFamily: "ecs.sn1ne",
}));
const defaultManagedKubernetes = new alicloud.cs.ManagedKubernetes("default", {
    name: `${name}-${defaultInteger.result}`,
    clusterSpec: "ack.pro.small",
    version: "1.24.6-aliyun.1",
    newNatGateway: true,
    nodeCidrMask: 26,
    proxyMode: "ipvs",
    serviceCidr: "172.23.0.0/16",
    podCidr: "10.95.0.0/16",
    workerVswitchIds: [vswitch.id],
});
const defaultKeyPair = new alicloud.ecs.KeyPair("default", {keyPairName: `${name}-${defaultInteger.result}`});
const defaultNodePool = new alicloud.cs.NodePool("default", {
    name: "desired_size",
    clusterId: defaultManagedKubernetes.id,
    vswitchIds: [vswitch.id],
    instanceTypes: [_default.apply(_default => _default.instanceTypes?.[0]?.id)],
    systemDiskCategory: "cloud_efficiency",
    systemDiskSize: 40,
    keyName: defaultKeyPair.keyPairName,
    desiredSize: "2",
});
const defaultEnvironment = new alicloud.arms.Environment("default", {
    environmentType: "CS",
    environmentName: `${name}-${defaultInteger.result}`,
    bindResourceId: defaultNodePool.clusterId,
    environmentSubType: "ManagedKubernetes",
});
const defaultAddonRelease = new alicloud.arms.AddonRelease("default", {
    aliyunLang: "zh",
    addonName: "mysql",
    environmentId: defaultEnvironment.id,
    addonVersion: "0.0.2",
    values: JSON.stringify({
        host: "mysql-service.default",
        password: "roots",
        port: 3306,
        username: "root",
    }),
});
const ids = alicloud.arms.getAddonReleasesOutput({
    environmentId: defaultAddonRelease.environmentId,
    ids: [defaultAddonRelease.id],
});
export const armsEnvServiceMonitorsId0 = ids.apply(ids => ids.releases?.[0]?.id);

import pulumi
import json
import pulumi_alicloud as alicloud
import pulumi_random as random
import pulumi_std as std

config = pulumi.Config()
name = config.get("name")
if name is None:
    name = "terraform-example"
default_integer = random.index.Integer("default",
    min=10000,
    max=99999)
enhanced = alicloud.vpc.get_enhanced_nat_available_zones()
vpc = alicloud.vpc.Network("vpc",
    description="api-resource-test1-hz",
    cidr_block="192.168.0.0/16",
    vpc_name=f"{name}-{default_integer['result']}")
vswitch = alicloud.vpc.Switch("vswitch",
    description="api-resource-test1-hz",
    vpc_id=vpc.id,
    vswitch_name=f"{name}-{default_integer['result']}",
    zone_id=enhanced.zones[0].zone_id,
    cidr_block=vpc.cidr_block.apply(lambda cidr_block: std.cidrsubnet_output(input=cidr_block,
        newbits=8,
        netnum=8)).apply(lambda invoke: invoke.result))
default_snapshot_policy = alicloud.ecs.SnapshotPolicy("default",
    name=f"{name}-{default_integer['result']}",
    repeat_weekdays=[
        "1",
        "2",
        "3",
    ],
    retention_days=-1,
    time_points=[
        "1",
        "22",
        "23",
    ])
default = vswitch.zone_id.apply(lambda zone_id: alicloud.ecs.get_instance_types_output(availability_zone=zone_id,
    cpu_core_count=2,
    memory_size=4,
    kubernetes_node_role="Worker",
    instance_type_family="ecs.sn1ne"))
default_managed_kubernetes = alicloud.cs.ManagedKubernetes("default",
    name=f"{name}-{default_integer['result']}",
    cluster_spec="ack.pro.small",
    version="1.24.6-aliyun.1",
    new_nat_gateway=True,
    node_cidr_mask=26,
    proxy_mode="ipvs",
    service_cidr="172.23.0.0/16",
    pod_cidr="10.95.0.0/16",
    worker_vswitch_ids=[vswitch.id])
default_key_pair = alicloud.ecs.KeyPair("default", key_pair_name=f"{name}-{default_integer['result']}")
default_node_pool = alicloud.cs.NodePool("default",
    name="desired_size",
    cluster_id=default_managed_kubernetes.id,
    vswitch_ids=[vswitch.id],
    instance_types=[default.instance_types[0].id],
    system_disk_category="cloud_efficiency",
    system_disk_size=40,
    key_name=default_key_pair.key_pair_name,
    desired_size="2")
default_environment = alicloud.arms.Environment("default",
    environment_type="CS",
    environment_name=f"{name}-{default_integer['result']}",
    bind_resource_id=default_node_pool.cluster_id,
    environment_sub_type="ManagedKubernetes")
default_addon_release = alicloud.arms.AddonRelease("default",
    aliyun_lang="zh",
    addon_name="mysql",
    environment_id=default_environment.id,
    addon_version="0.0.2",
    values=json.dumps({
        "host": "mysql-service.default",
        "password": "roots",
        "port": 3306,
        "username": "root",
    }))
ids = alicloud.arms.get_addon_releases_output(environment_id=default_addon_release.environment_id,
    ids=[default_addon_release.id])
pulumi.export("armsEnvServiceMonitorsId0", ids.releases[0].id)

package main

import (
	"encoding/json"
	"fmt"

	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/arms"
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/cs"
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/ecs"
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/vpc"
	"github.com/pulumi/pulumi-random/sdk/v4/go/random"
	"github.com/pulumi/pulumi-std/sdk/go/std"
	"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
}
enhanced, err := vpc.GetEnhancedNatAvailableZones(ctx, &vpc.GetEnhancedNatAvailableZonesArgs{
}, nil);
if err != nil {
return err
}
vpc, err := vpc.NewNetwork(ctx, "vpc", &vpc.NetworkArgs{
Description: pulumi.String("api-resource-test1-hz"),
CidrBlock: pulumi.String("192.168.0.0/16"),
VpcName: pulumi.Sprintf("%v-%v", name, defaultInteger.Result),
})
if err != nil {
return err
}
vswitch, err := vpc.NewSwitch(ctx, "vswitch", &vpc.SwitchArgs{
Description: pulumi.String("api-resource-test1-hz"),
VpcId: vpc.ID(),
VswitchName: pulumi.Sprintf("%v-%v", name, defaultInteger.Result),
ZoneId: pulumi.String(enhanced.Zones[0].ZoneId),
CidrBlock: pulumi.String(vpc.CidrBlock.ApplyT(func(cidrBlock string) (std.CidrsubnetResult, error) {
return std.CidrsubnetResult(interface{}(std.CidrsubnetOutput(ctx, std.CidrsubnetOutputArgs{
Input: cidrBlock,
Newbits: 8,
Netnum: 8,
}, nil))), nil
}).(std.CidrsubnetResultOutput).ApplyT(func(invoke std.CidrsubnetResult) (*string, error) {
return invoke.Result, nil
}).(pulumi.StringPtrOutput)),
})
if err != nil {
return err
}
_, err = ecs.NewSnapshotPolicy(ctx, "default", &ecs.SnapshotPolicyArgs{
Name: pulumi.Sprintf("%v-%v", name, defaultInteger.Result),
RepeatWeekdays: pulumi.StringArray{
pulumi.String("1"),
pulumi.String("2"),
pulumi.String("3"),
},
RetentionDays: pulumi.Int(-1),
TimePoints: pulumi.StringArray{
pulumi.String("1"),
pulumi.String("22"),
pulumi.String("23"),
},
})
if err != nil {
return err
}
_default := vswitch.ZoneId.ApplyT(func(zoneId string) (ecs.GetInstanceTypesResult, error) {
return ecs.GetInstanceTypesResult(interface{}(ecs.GetInstanceTypesOutput(ctx, ecs.GetInstanceTypesOutputArgs{
AvailabilityZone: zoneId,
CpuCoreCount: 2,
MemorySize: 4,
KubernetesNodeRole: "Worker",
InstanceTypeFamily: "ecs.sn1ne",
}, nil))), nil
}).(ecs.GetInstanceTypesResultOutput)
defaultManagedKubernetes, err := cs.NewManagedKubernetes(ctx, "default", &cs.ManagedKubernetesArgs{
Name: pulumi.Sprintf("%v-%v", name, defaultInteger.Result),
ClusterSpec: pulumi.String("ack.pro.small"),
Version: pulumi.String("1.24.6-aliyun.1"),
NewNatGateway: pulumi.Bool(true),
NodeCidrMask: pulumi.Int(26),
ProxyMode: pulumi.String("ipvs"),
ServiceCidr: pulumi.String("172.23.0.0/16"),
PodCidr: pulumi.String("10.95.0.0/16"),
WorkerVswitchIds: pulumi.StringArray{
vswitch.ID(),
},
})
if err != nil {
return err
}
defaultKeyPair, err := ecs.NewKeyPair(ctx, "default", &ecs.KeyPairArgs{
KeyPairName: pulumi.Sprintf("%v-%v", name, defaultInteger.Result),
})
if err != nil {
return err
}
defaultNodePool, err := cs.NewNodePool(ctx, "default", &cs.NodePoolArgs{
Name: pulumi.String("desired_size"),
ClusterId: defaultManagedKubernetes.ID(),
VswitchIds: pulumi.StringArray{
vswitch.ID(),
},
InstanceTypes: pulumi.StringArray{
pulumi.String(_default.ApplyT(func(_default ecs.GetInstanceTypesResult) (*string, error) {
return &default.InstanceTypes[0].Id, nil
}).(pulumi.StringPtrOutput)),
},
SystemDiskCategory: pulumi.String("cloud_efficiency"),
SystemDiskSize: pulumi.Int(40),
KeyName: defaultKeyPair.KeyPairName,
DesiredSize: pulumi.String("2"),
})
if err != nil {
return err
}
defaultEnvironment, err := arms.NewEnvironment(ctx, "default", &arms.EnvironmentArgs{
EnvironmentType: pulumi.String("CS"),
EnvironmentName: pulumi.Sprintf("%v-%v", name, defaultInteger.Result),
BindResourceId: defaultNodePool.ClusterId,
EnvironmentSubType: pulumi.String("ManagedKubernetes"),
})
if err != nil {
return err
}
tmpJSON0, err := json.Marshal(map[string]interface{}{
"host": "mysql-service.default",
"password": "roots",
"port": 3306,
"username": "root",
})
if err != nil {
return err
}
json0 := string(tmpJSON0)
defaultAddonRelease, err := arms.NewAddonRelease(ctx, "default", &arms.AddonReleaseArgs{
AliyunLang: pulumi.String("zh"),
AddonName: pulumi.String("mysql"),
EnvironmentId: defaultEnvironment.ID(),
AddonVersion: pulumi.String("0.0.2"),
Values: pulumi.String(json0),
})
if err != nil {
return err
}
ids := arms.GetAddonReleasesOutput(ctx, arms.GetAddonReleasesOutputArgs{
EnvironmentId: defaultAddonRelease.EnvironmentId,
Ids: pulumi.StringArray{
defaultAddonRelease.ID(),
},
}, nil);
ctx.Export("armsEnvServiceMonitorsId0", ids.ApplyT(func(ids arms.GetAddonReleasesResult) (*string, error) {
return &ids.Releases[0].Id, nil
}).(pulumi.StringPtrOutput))
return nil
})
}

using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using Pulumi;
using AliCloud = Pulumi.AliCloud;
using Random = Pulumi.Random;
using Std = Pulumi.Std;

return await Deployment.RunAsync(() => 
{
    var config = new Config();
    var name = config.Get("name") ?? "terraform-example";
    var defaultInteger = new Random.Index.Integer("default", new()
    {
        Min = 10000,
        Max = 99999,
    });

    var enhanced = AliCloud.Vpc.GetEnhancedNatAvailableZones.Invoke();

    var vpc = new AliCloud.Vpc.Network("vpc", new()
    {
        Description = "api-resource-test1-hz",
        CidrBlock = "192.168.0.0/16",
        VpcName = $"{name}-{defaultInteger.Result}",
    });

    var vswitch = new AliCloud.Vpc.Switch("vswitch", new()
    {
        Description = "api-resource-test1-hz",
        VpcId = vpc.Id,
        VswitchName = $"{name}-{defaultInteger.Result}",
        ZoneId = enhanced.Apply(getEnhancedNatAvailableZonesResult => getEnhancedNatAvailableZonesResult.Zones[0]?.ZoneId),
        CidrBlock = vpc.CidrBlock.Apply(cidrBlock => Std.Cidrsubnet.Invoke(new()
        {
            Input = cidrBlock,
            Newbits = 8,
            Netnum = 8,
        })).Apply(invoke => invoke.Result),
    });

    var defaultSnapshotPolicy = new AliCloud.Ecs.SnapshotPolicy("default", new()
    {
        Name = $"{name}-{defaultInteger.Result}",
        RepeatWeekdays = new[]
        {
            "1",
            "2",
            "3",
        },
        RetentionDays = -1,
        TimePoints = new[]
        {
            "1",
            "22",
            "23",
        },
    });

    var @default = AliCloud.Ecs.GetInstanceTypes.Invoke(new()
    {
        AvailabilityZone = vswitch.ZoneId,
        CpuCoreCount = 2,
        MemorySize = 4,
        KubernetesNodeRole = "Worker",
        InstanceTypeFamily = "ecs.sn1ne",
    });

    var defaultManagedKubernetes = new AliCloud.CS.ManagedKubernetes("default", new()
    {
        Name = $"{name}-{defaultInteger.Result}",
        ClusterSpec = "ack.pro.small",
        Version = "1.24.6-aliyun.1",
        NewNatGateway = true,
        NodeCidrMask = 26,
        ProxyMode = "ipvs",
        ServiceCidr = "172.23.0.0/16",
        PodCidr = "10.95.0.0/16",
        WorkerVswitchIds = new[]
        {
            vswitch.Id,
        },
    });

    var defaultKeyPair = new AliCloud.Ecs.KeyPair("default", new()
    {
        KeyPairName = $"{name}-{defaultInteger.Result}",
    });

    var defaultNodePool = new AliCloud.CS.NodePool("default", new()
    {
        Name = "desired_size",
        ClusterId = defaultManagedKubernetes.Id,
        VswitchIds = new[]
        {
            vswitch.Id,
        },
        InstanceTypes = new[]
        {
            @default.Apply(@default => @default.Apply(getInstanceTypesResult => getInstanceTypesResult.InstanceTypes[0]?.Id)),
        },
        SystemDiskCategory = "cloud_efficiency",
        SystemDiskSize = 40,
        KeyName = defaultKeyPair.KeyPairName,
        DesiredSize = "2",
    });

    var defaultEnvironment = new AliCloud.Arms.Environment("default", new()
    {
        EnvironmentType = "CS",
        EnvironmentName = $"{name}-{defaultInteger.Result}",
        BindResourceId = defaultNodePool.ClusterId,
        EnvironmentSubType = "ManagedKubernetes",
    });

    var defaultAddonRelease = new AliCloud.Arms.AddonRelease("default", new()
    {
        AliyunLang = "zh",
        AddonName = "mysql",
        EnvironmentId = defaultEnvironment.Id,
        AddonVersion = "0.0.2",
        Values = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["host"] = "mysql-service.default",
            ["password"] = "roots",
            ["port"] = 3306,
            ["username"] = "root",
        }),
    });

    var ids = AliCloud.Arms.GetAddonReleases.Invoke(new()
    {
        EnvironmentId = defaultAddonRelease.EnvironmentId,
        Ids = new[]
        {
            defaultAddonRelease.Id,
        },
    });

    return new Dictionary<string, object?>
    {
        ["armsEnvServiceMonitorsId0"] = ids.Apply(getAddonReleasesResult => getAddonReleasesResult.Releases[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.vpc.VpcFunctions;
import com.pulumi.alicloud.vpc.inputs.GetEnhancedNatAvailableZonesArgs;
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.std.StdFunctions;
import com.pulumi.std.inputs.CidrsubnetArgs;
import com.pulumi.alicloud.ecs.SnapshotPolicy;
import com.pulumi.alicloud.ecs.SnapshotPolicyArgs;
import com.pulumi.alicloud.ecs.EcsFunctions;
import com.pulumi.alicloud.ecs.inputs.GetInstanceTypesArgs;
import com.pulumi.alicloud.cs.ManagedKubernetes;
import com.pulumi.alicloud.cs.ManagedKubernetesArgs;
import com.pulumi.alicloud.ecs.KeyPair;
import com.pulumi.alicloud.ecs.KeyPairArgs;
import com.pulumi.alicloud.cs.NodePool;
import com.pulumi.alicloud.cs.NodePoolArgs;
import com.pulumi.alicloud.arms.Environment;
import com.pulumi.alicloud.arms.EnvironmentArgs;
import com.pulumi.alicloud.arms.AddonRelease;
import com.pulumi.alicloud.arms.AddonReleaseArgs;
import com.pulumi.alicloud.arms.ArmsFunctions;
import com.pulumi.alicloud.arms.inputs.GetAddonReleasesArgs;
import static com.pulumi.codegen.internal.Serialization.*;
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("terraform-example");
        var defaultInteger = new Integer("defaultInteger", IntegerArgs.builder()
            .min(10000)
            .max(99999)
            .build());

        final var enhanced = VpcFunctions.getEnhancedNatAvailableZones(GetEnhancedNatAvailableZonesArgs.builder()
            .build());

        var vpc = new Network("vpc", NetworkArgs.builder()
            .description("api-resource-test1-hz")
            .cidrBlock("192.168.0.0/16")
            .vpcName(String.format("%s-%s", name,defaultInteger.result()))
            .build());

        var vswitch = new Switch("vswitch", SwitchArgs.builder()
            .description("api-resource-test1-hz")
            .vpcId(vpc.id())
            .vswitchName(String.format("%s-%s", name,defaultInteger.result()))
            .zoneId(enhanced.zones()[0].zoneId())
            .cidrBlock(vpc.cidrBlock().applyValue(_cidrBlock -> StdFunctions.cidrsubnet(CidrsubnetArgs.builder()
                .input(_cidrBlock)
                .newbits(8)
                .netnum(8)
                .build())).applyValue(_invoke -> _invoke.result()))
            .build());

        var defaultSnapshotPolicy = new SnapshotPolicy("defaultSnapshotPolicy", SnapshotPolicyArgs.builder()
            .name(String.format("%s-%s", name,defaultInteger.result()))
            .repeatWeekdays(            
                "1",
                "2",
                "3")
            .retentionDays(-1)
            .timePoints(            
                "1",
                "22",
                "23")
            .build());

        final var default = vswitch.zoneId().applyValue(_zoneId -> EcsFunctions.getInstanceTypes(GetInstanceTypesArgs.builder()
            .availabilityZone(_zoneId)
            .cpuCoreCount(2)
            .memorySize(4)
            .kubernetesNodeRole("Worker")
            .instanceTypeFamily("ecs.sn1ne")
            .build()));

        var defaultManagedKubernetes = new ManagedKubernetes("defaultManagedKubernetes", ManagedKubernetesArgs.builder()
            .name(String.format("%s-%s", name,defaultInteger.result()))
            .clusterSpec("ack.pro.small")
            .version("1.24.6-aliyun.1")
            .newNatGateway(true)
            .nodeCidrMask(26)
            .proxyMode("ipvs")
            .serviceCidr("172.23.0.0/16")
            .podCidr("10.95.0.0/16")
            .workerVswitchIds(vswitch.id())
            .build());

        var defaultKeyPair = new KeyPair("defaultKeyPair", KeyPairArgs.builder()
            .keyPairName(String.format("%s-%s", name,defaultInteger.result()))
            .build());

        var defaultNodePool = new NodePool("defaultNodePool", NodePoolArgs.builder()
            .name("desired_size")
            .clusterId(defaultManagedKubernetes.id())
            .vswitchIds(vswitch.id())
            .instanceTypes(default_.applyValue(_default_ -> _default_.instanceTypes()[0].id()))
            .systemDiskCategory("cloud_efficiency")
            .systemDiskSize(40)
            .keyName(defaultKeyPair.keyPairName())
            .desiredSize("2")
            .build());

        var defaultEnvironment = new Environment("defaultEnvironment", EnvironmentArgs.builder()
            .environmentType("CS")
            .environmentName(String.format("%s-%s", name,defaultInteger.result()))
            .bindResourceId(defaultNodePool.clusterId())
            .environmentSubType("ManagedKubernetes")
            .build());

        var defaultAddonRelease = new AddonRelease("defaultAddonRelease", AddonReleaseArgs.builder()
            .aliyunLang("zh")
            .addonName("mysql")
            .environmentId(defaultEnvironment.id())
            .addonVersion("0.0.2")
            .values(serializeJson(
                jsonObject(
                    jsonProperty("host", "mysql-service.default"),
                    jsonProperty("password", "roots"),
                    jsonProperty("port", 3306),
                    jsonProperty("username", "root")
                )))
            .build());

        final var ids = ArmsFunctions.getAddonReleases(GetAddonReleasesArgs.builder()
            .environmentId(defaultAddonRelease.environmentId())
            .ids(defaultAddonRelease.id())
            .build());

        ctx.export("armsEnvServiceMonitorsId0", ids.applyValue(_ids -> _ids.releases()[0].id()));
    }
}

configuration:
  name:
    type: string
    default: terraform-example
resources:
  defaultInteger:
    type: random:Integer
    name: default
    properties:
      min: 10000
      max: 99999
  vpc:
    type: alicloud:vpc:Network
    properties:
      description: api-resource-test1-hz
      cidrBlock: 192.168.0.0/16
      vpcName: ${name}-${defaultInteger.result}
  vswitch:
    type: alicloud:vpc:Switch
    properties:
      description: api-resource-test1-hz
      vpcId: ${vpc.id}
      vswitchName: ${name}-${defaultInteger.result}
      zoneId: ${enhanced.zones[0].zoneId}
      cidrBlock:
        fn::invoke:
          function: std:cidrsubnet
          arguments:
            input: ${vpc.cidrBlock}
            newbits: 8
            netnum: 8
          return: result
  defaultSnapshotPolicy:
    type: alicloud:ecs:SnapshotPolicy
    name: default
    properties:
      name: ${name}-${defaultInteger.result}
      repeatWeekdays:
        - '1'
        - '2'
        - '3'
      retentionDays: -1
      timePoints:
        - '1'
        - '22'
        - '23'
  defaultManagedKubernetes:
    type: alicloud:cs:ManagedKubernetes
    name: default
    properties:
      name: ${name}-${defaultInteger.result}
      clusterSpec: ack.pro.small
      version: 1.24.6-aliyun.1
      newNatGateway: true
      nodeCidrMask: 26
      proxyMode: ipvs
      serviceCidr: 172.23.0.0/16
      podCidr: 10.95.0.0/16
      workerVswitchIds:
        - ${vswitch.id}
  defaultKeyPair:
    type: alicloud:ecs:KeyPair
    name: default
    properties:
      keyPairName: ${name}-${defaultInteger.result}
  defaultNodePool:
    type: alicloud:cs:NodePool
    name: default
    properties:
      name: desired_size
      clusterId: ${defaultManagedKubernetes.id}
      vswitchIds:
        - ${vswitch.id}
      instanceTypes:
        - ${default.instanceTypes[0].id}
      systemDiskCategory: cloud_efficiency
      systemDiskSize: 40
      keyName: ${defaultKeyPair.keyPairName}
      desiredSize: 2
  defaultEnvironment:
    type: alicloud:arms:Environment
    name: default
    properties:
      environmentType: CS
      environmentName: ${name}-${defaultInteger.result}
      bindResourceId: ${defaultNodePool.clusterId}
      environmentSubType: ManagedKubernetes
  defaultAddonRelease:
    type: alicloud:arms:AddonRelease
    name: default
    properties:
      aliyunLang: zh
      addonName: mysql
      environmentId: ${defaultEnvironment.id}
      addonVersion: 0.0.2
      values:
        fn::toJSON:
          host: mysql-service.default
          password: roots
          port: 3306
          username: root
variables:
  enhanced:
    fn::invoke:
      function: alicloud:vpc:getEnhancedNatAvailableZones
      arguments: {}
  default:
    fn::invoke:
      function: alicloud:ecs:getInstanceTypes
      arguments:
        availabilityZone: ${vswitch.zoneId}
        cpuCoreCount: 2
        memorySize: 4
        kubernetesNodeRole: Worker
        instanceTypeFamily: ecs.sn1ne
  ids:
    fn::invoke:
      function: alicloud:arms:getAddonReleases
      arguments:
        environmentId: ${defaultAddonRelease.environmentId}
        ids:
          - ${defaultAddonRelease.id}
outputs:
  armsEnvServiceMonitorsId0: ${ids.releases[0].id}

function getAddonReleases(args: GetAddonReleasesArgs, opts?: InvokeOptions): Promise<GetAddonReleasesResult>
function getAddonReleasesOutput(args: GetAddonReleasesOutputArgs, opts?: InvokeOptions): Output<GetAddonReleasesResult>

def get_addon_releases(environment_id: Optional[str] = None,
                       ids: Optional[Sequence[str]] = None,
                       name_regex: Optional[str] = None,
                       output_file: Optional[str] = None,
                       opts: Optional[InvokeOptions] = None) -> GetAddonReleasesResult
def get_addon_releases_output(environment_id: Optional[pulumi.Input[str]] = None,
                       ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                       name_regex: Optional[pulumi.Input[str]] = None,
                       output_file: Optional[pulumi.Input[str]] = None,
                       opts: Optional[InvokeOptions] = None) -> Output[GetAddonReleasesResult]

func GetAddonReleases(ctx *Context, args *GetAddonReleasesArgs, opts ...InvokeOption) (*GetAddonReleasesResult, error)
func GetAddonReleasesOutput(ctx *Context, args *GetAddonReleasesOutputArgs, opts ...InvokeOption) GetAddonReleasesResultOutput

public static class GetAddonReleases 
{
    public static Task<GetAddonReleasesResult> InvokeAsync(GetAddonReleasesArgs args, InvokeOptions? opts = null)
    public static Output<GetAddonReleasesResult> Invoke(GetAddonReleasesInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetAddonReleasesResult> getAddonReleases(GetAddonReleasesArgs args, InvokeOptions options)
public static Output<GetAddonReleasesResult> getAddonReleases(GetAddonReleasesArgs args, InvokeOptions options)

fn::invoke:
  function: alicloud:arms/getAddonReleases:getAddonReleases
  arguments:
    # arguments dictionary