volcengine.vke.NodePools

import * as pulumi from "@pulumi/pulumi";
import * as volcengine from "@pulumi/volcengine";
import * as volcengine from "@volcengine/pulumi";

const fooZones = volcengine.ecs.Zones({});
const fooVpc = new volcengine.vpc.Vpc("fooVpc", {
    vpcName: "acc-test-vpc",
    cidrBlock: "172.16.0.0/16",
});
const fooSubnet = new volcengine.vpc.Subnet("fooSubnet", {
    subnetName: "acc-test-subnet",
    cidrBlock: "172.16.0.0/24",
    zoneId: fooZones.then(fooZones => fooZones.zones?.[0]?.id),
    vpcId: fooVpc.id,
});
const fooSecurityGroup = new volcengine.vpc.SecurityGroup("fooSecurityGroup", {
    securityGroupName: "acc-test-security-group",
    vpcId: fooVpc.id,
});
const fooImages = volcengine.ecs.Images({
    nameRegex: "veLinux 1.0 CentOS兼容版 64位",
});
const fooCluster = new volcengine.vke.Cluster("fooCluster", {
    description: "created by terraform",
    deleteProtectionEnabled: false,
    clusterConfig: {
        subnetIds: [fooSubnet.id],
        apiServerPublicAccessEnabled: true,
        apiServerPublicAccessConfig: {
            publicAccessNetworkConfig: {
                billingType: "PostPaidByBandwidth",
                bandwidth: 1,
            },
        },
        resourcePublicAccessDefaultEnabled: true,
    },
    podsConfig: {
        podNetworkMode: "VpcCniShared",
        vpcCniConfig: {
            subnetIds: [fooSubnet.id],
        },
    },
    servicesConfig: {
        serviceCidrsv4s: ["172.30.0.0/18"],
    },
    tags: [{
        key: "tf-k1",
        value: "tf-v1",
    }],
});
const fooNodePool: volcengine.vke.NodePool[] = [];
for (const range = {value: 0}; range.value < 3; range.value++) {
    fooNodePool.push(new volcengine.vke.NodePool(`fooNodePool-${range.value}`, {
        clusterId: fooCluster.id,
        autoScaling: {
            enabled: true,
            minReplicas: 0,
            maxReplicas: 5,
            desiredReplicas: 0,
            priority: 5,
            subnetPolicy: "ZoneBalance",
        },
        nodeConfig: {
            instanceTypeIds: ["ecs.g1ie.xlarge"],
            subnetIds: [fooSubnet.id],
            imageId: fooImages.then(fooImages => .filter(image => image.imageName == "veLinux 1.0 CentOS兼容版 64位").map(image => (image.imageId))[0]),
            systemVolume: {
                type: "ESSD_PL0",
                size: 60,
            },
            dataVolumes: [
                {
                    type: "ESSD_PL0",
                    size: 60,
                    mountPoint: "/tf1",
                },
                {
                    type: "ESSD_PL0",
                    size: 60,
                    mountPoint: "/tf2",
                },
            ],
            initializeScript: "ZWNobyBoZWxsbyB0ZXJyYWZvcm0h",
            security: {
                login: {
                    password: "UHdkMTIzNDU2",
                },
                securityStrategies: ["Hids"],
                securityGroupIds: [fooSecurityGroup.id],
            },
            additionalContainerStorageEnabled: true,
            instanceChargeType: "PostPaid",
            namePrefix: "acc-test",
            ecsTags: [{
                key: "ecs_k1",
                value: "ecs_v1",
            }],
        },
        kubernetesConfig: {
            labels: [{
                key: "label1",
                value: "value1",
            }],
            taints: [{
                key: "taint-key/node-type",
                value: "taint-value",
                effect: "NoSchedule",
            }],
            cordon: true,
        },
        tags: [{
            key: "node-pool-k1",
            value: "node-pool-v1",
        }],
    }));
}
const fooNodePools = volcengine.vke.NodePoolsOutput({
    ids: fooNodePool.map(__item => __item.id),
});

import pulumi
import pulumi_volcengine as volcengine

foo_zones = volcengine.ecs.zones()
foo_vpc = volcengine.vpc.Vpc("fooVpc",
    vpc_name="acc-test-vpc",
    cidr_block="172.16.0.0/16")
foo_subnet = volcengine.vpc.Subnet("fooSubnet",
    subnet_name="acc-test-subnet",
    cidr_block="172.16.0.0/24",
    zone_id=foo_zones.zones[0].id,
    vpc_id=foo_vpc.id)
foo_security_group = volcengine.vpc.SecurityGroup("fooSecurityGroup",
    security_group_name="acc-test-security-group",
    vpc_id=foo_vpc.id)
foo_images = volcengine.ecs.images(name_regex="veLinux 1.0 CentOS兼容版 64位")
foo_cluster = volcengine.vke.Cluster("fooCluster",
    description="created by terraform",
    delete_protection_enabled=False,
    cluster_config=volcengine.vke.ClusterClusterConfigArgs(
        subnet_ids=[foo_subnet.id],
        api_server_public_access_enabled=True,
        api_server_public_access_config=volcengine.vke.ClusterClusterConfigApiServerPublicAccessConfigArgs(
            public_access_network_config=volcengine.vke.ClusterClusterConfigApiServerPublicAccessConfigPublicAccessNetworkConfigArgs(
                billing_type="PostPaidByBandwidth",
                bandwidth=1,
            ),
        ),
        resource_public_access_default_enabled=True,
    ),
    pods_config=volcengine.vke.ClusterPodsConfigArgs(
        pod_network_mode="VpcCniShared",
        vpc_cni_config=volcengine.vke.ClusterPodsConfigVpcCniConfigArgs(
            subnet_ids=[foo_subnet.id],
        ),
    ),
    services_config=volcengine.vke.ClusterServicesConfigArgs(
        service_cidrsv4s=["172.30.0.0/18"],
    ),
    tags=[volcengine.vke.ClusterTagArgs(
        key="tf-k1",
        value="tf-v1",
    )])
foo_node_pool = []
for range in [{"value": i} for i in range(0, 3)]:
    foo_node_pool.append(volcengine.vke.NodePool(f"fooNodePool-{range['value']}",
        cluster_id=foo_cluster.id,
        auto_scaling=volcengine.vke.NodePoolAutoScalingArgs(
            enabled=True,
            min_replicas=0,
            max_replicas=5,
            desired_replicas=0,
            priority=5,
            subnet_policy="ZoneBalance",
        ),
        node_config=volcengine.vke.NodePoolNodeConfigArgs(
            instance_type_ids=["ecs.g1ie.xlarge"],
            subnet_ids=[foo_subnet.id],
            image_id=[image.image_id for image in foo_images.images if image.image_name == "veLinux 1.0 CentOS兼容版 64位"][0],
            system_volume=volcengine.vke.NodePoolNodeConfigSystemVolumeArgs(
                type="ESSD_PL0",
                size=60,
            ),
            data_volumes=[
                volcengine.vke.NodePoolNodeConfigDataVolumeArgs(
                    type="ESSD_PL0",
                    size=60,
                    mount_point="/tf1",
                ),
                volcengine.vke.NodePoolNodeConfigDataVolumeArgs(
                    type="ESSD_PL0",
                    size=60,
                    mount_point="/tf2",
                ),
            ],
            initialize_script="ZWNobyBoZWxsbyB0ZXJyYWZvcm0h",
            security=volcengine.vke.NodePoolNodeConfigSecurityArgs(
                login=volcengine.vke.NodePoolNodeConfigSecurityLoginArgs(
                    password="UHdkMTIzNDU2",
                ),
                security_strategies=["Hids"],
                security_group_ids=[foo_security_group.id],
            ),
            additional_container_storage_enabled=True,
            instance_charge_type="PostPaid",
            name_prefix="acc-test",
            ecs_tags=[volcengine.vke.NodePoolNodeConfigEcsTagArgs(
                key="ecs_k1",
                value="ecs_v1",
            )],
        ),
        kubernetes_config=volcengine.vke.NodePoolKubernetesConfigArgs(
            labels=[volcengine.vke.NodePoolKubernetesConfigLabelArgs(
                key="label1",
                value="value1",
            )],
            taints=[volcengine.vke.NodePoolKubernetesConfigTaintArgs(
                key="taint-key/node-type",
                value="taint-value",
                effect="NoSchedule",
            )],
            cordon=True,
        ),
        tags=[volcengine.vke.NodePoolTagArgs(
            key="node-pool-k1",
            value="node-pool-v1",
        )]))
foo_node_pools = volcengine.vke.node_pools_output(ids=[__item.id for __item in foo_node_pool])

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/volcengine/pulumi-volcengine/sdk/go/volcengine/ecs"
	"github.com/volcengine/pulumi-volcengine/sdk/go/volcengine/vke"
	"github.com/volcengine/pulumi-volcengine/sdk/go/volcengine/vpc"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
fooZones, err := ecs.Zones(ctx, nil, nil);
if err != nil {
return err
}
fooVpc, err := vpc.NewVpc(ctx, "fooVpc", &vpc.VpcArgs{
VpcName: pulumi.String("acc-test-vpc"),
CidrBlock: pulumi.String("172.16.0.0/16"),
})
if err != nil {
return err
}
fooSubnet, err := vpc.NewSubnet(ctx, "fooSubnet", &vpc.SubnetArgs{
SubnetName: pulumi.String("acc-test-subnet"),
CidrBlock: pulumi.String("172.16.0.0/24"),
ZoneId: pulumi.String(fooZones.Zones[0].Id),
VpcId: fooVpc.ID(),
})
if err != nil {
return err
}
fooSecurityGroup, err := vpc.NewSecurityGroup(ctx, "fooSecurityGroup", &vpc.SecurityGroupArgs{
SecurityGroupName: pulumi.String("acc-test-security-group"),
VpcId: fooVpc.ID(),
})
if err != nil {
return err
}
fooImages, err := ecs.Images(ctx, &ecs.ImagesArgs{
NameRegex: pulumi.StringRef("veLinux 1.0 CentOS兼容版 64位"),
}, nil);
if err != nil {
return err
}
fooCluster, err := vke.NewCluster(ctx, "fooCluster", &vke.ClusterArgs{
Description: pulumi.String("created by terraform"),
DeleteProtectionEnabled: pulumi.Bool(false),
ClusterConfig: &vke.ClusterClusterConfigArgs{
SubnetIds: pulumi.StringArray{
fooSubnet.ID(),
},
ApiServerPublicAccessEnabled: pulumi.Bool(true),
ApiServerPublicAccessConfig: &vke.ClusterClusterConfigApiServerPublicAccessConfigArgs{
PublicAccessNetworkConfig: &vke.ClusterClusterConfigApiServerPublicAccessConfigPublicAccessNetworkConfigArgs{
BillingType: pulumi.String("PostPaidByBandwidth"),
Bandwidth: pulumi.Int(1),
},
},
ResourcePublicAccessDefaultEnabled: pulumi.Bool(true),
},
PodsConfig: &vke.ClusterPodsConfigArgs{
PodNetworkMode: pulumi.String("VpcCniShared"),
VpcCniConfig: &vke.ClusterPodsConfigVpcCniConfigArgs{
SubnetIds: pulumi.StringArray{
fooSubnet.ID(),
},
},
},
ServicesConfig: &vke.ClusterServicesConfigArgs{
ServiceCidrsv4s: pulumi.StringArray{
pulumi.String("172.30.0.0/18"),
},
},
Tags: vke.ClusterTagArray{
&vke.ClusterTagArgs{
Key: pulumi.String("tf-k1"),
Value: pulumi.String("tf-v1"),
},
},
})
if err != nil {
return err
}
var fooNodePool []*vke.NodePool
for index := 0; index < 3; index++ {
    key0 := index
    _ := index
__res, err := vke.NewNodePool(ctx, fmt.Sprintf("fooNodePool-%v", key0), &vke.NodePoolArgs{
ClusterId: fooCluster.ID(),
AutoScaling: &vke.NodePoolAutoScalingArgs{
Enabled: pulumi.Bool(true),
MinReplicas: pulumi.Int(0),
MaxReplicas: pulumi.Int(5),
DesiredReplicas: pulumi.Int(0),
Priority: pulumi.Int(5),
SubnetPolicy: pulumi.String("ZoneBalance"),
},
NodeConfig: &vke.NodePoolNodeConfigArgs{
InstanceTypeIds: pulumi.StringArray{
pulumi.String("ecs.g1ie.xlarge"),
},
SubnetIds: pulumi.StringArray{
fooSubnet.ID(),
},
ImageId: "TODO: For expression"[0],
SystemVolume: &vke.NodePoolNodeConfigSystemVolumeArgs{
Type: pulumi.String("ESSD_PL0"),
Size: pulumi.Int(60),
},
DataVolumes: vke.NodePoolNodeConfigDataVolumeArray{
&vke.NodePoolNodeConfigDataVolumeArgs{
Type: pulumi.String("ESSD_PL0"),
Size: pulumi.Int(60),
MountPoint: pulumi.String("/tf1"),
},
&vke.NodePoolNodeConfigDataVolumeArgs{
Type: pulumi.String("ESSD_PL0"),
Size: pulumi.Int(60),
MountPoint: pulumi.String("/tf2"),
},
},
InitializeScript: pulumi.String("ZWNobyBoZWxsbyB0ZXJyYWZvcm0h"),
Security: &vke.NodePoolNodeConfigSecurityArgs{
Login: &vke.NodePoolNodeConfigSecurityLoginArgs{
Password: pulumi.String("UHdkMTIzNDU2"),
},
SecurityStrategies: pulumi.StringArray{
pulumi.String("Hids"),
},
SecurityGroupIds: pulumi.StringArray{
fooSecurityGroup.ID(),
},
},
AdditionalContainerStorageEnabled: pulumi.Bool(true),
InstanceChargeType: pulumi.String("PostPaid"),
NamePrefix: pulumi.String("acc-test"),
EcsTags: vke.NodePoolNodeConfigEcsTagArray{
&vke.NodePoolNodeConfigEcsTagArgs{
Key: pulumi.String("ecs_k1"),
Value: pulumi.String("ecs_v1"),
},
},
},
KubernetesConfig: &vke.NodePoolKubernetesConfigArgs{
Labels: vke.NodePoolKubernetesConfigLabelArray{
&vke.NodePoolKubernetesConfigLabelArgs{
Key: pulumi.String("label1"),
Value: pulumi.String("value1"),
},
},
Taints: vke.NodePoolKubernetesConfigTaintArray{
&vke.NodePoolKubernetesConfigTaintArgs{
Key: pulumi.String("taint-key/node-type"),
Value: pulumi.String("taint-value"),
Effect: pulumi.String("NoSchedule"),
},
},
Cordon: pulumi.Bool(true),
},
Tags: vke.NodePoolTagArray{
&vke.NodePoolTagArgs{
Key: pulumi.String("node-pool-k1"),
Value: pulumi.String("node-pool-v1"),
},
},
})
if err != nil {
return err
}
fooNodePool = append(fooNodePool, __res)
}
_ = vke.NodePoolsOutput(ctx, vke.NodePoolsOutputArgs{
Ids: %!v(PANIC=Format method: fatal: A failure has occurred: unlowered splat expression @ #-functions-volcengine:vke-nodePools:NodePools.pp:113,9-26),
}, nil);
return nil
})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Volcengine = Pulumi.Volcengine;

return await Deployment.RunAsync(() => 
{
    var fooZones = Volcengine.Ecs.Zones.Invoke();

    var fooVpc = new Volcengine.Vpc.Vpc("fooVpc", new()
    {
        VpcName = "acc-test-vpc",
        CidrBlock = "172.16.0.0/16",
    });

    var fooSubnet = new Volcengine.Vpc.Subnet("fooSubnet", new()
    {
        SubnetName = "acc-test-subnet",
        CidrBlock = "172.16.0.0/24",
        ZoneId = fooZones.Apply(zonesResult => zonesResult.Zones[0]?.Id),
        VpcId = fooVpc.Id,
    });

    var fooSecurityGroup = new Volcengine.Vpc.SecurityGroup("fooSecurityGroup", new()
    {
        SecurityGroupName = "acc-test-security-group",
        VpcId = fooVpc.Id,
    });

    var fooImages = Volcengine.Ecs.Images.Invoke(new()
    {
        NameRegex = "veLinux 1.0 CentOS兼容版 64位",
    });

    var fooCluster = new Volcengine.Vke.Cluster("fooCluster", new()
    {
        Description = "created by terraform",
        DeleteProtectionEnabled = false,
        ClusterConfig = new Volcengine.Vke.Inputs.ClusterClusterConfigArgs
        {
            SubnetIds = new[]
            {
                fooSubnet.Id,
            },
            ApiServerPublicAccessEnabled = true,
            ApiServerPublicAccessConfig = new Volcengine.Vke.Inputs.ClusterClusterConfigApiServerPublicAccessConfigArgs
            {
                PublicAccessNetworkConfig = new Volcengine.Vke.Inputs.ClusterClusterConfigApiServerPublicAccessConfigPublicAccessNetworkConfigArgs
                {
                    BillingType = "PostPaidByBandwidth",
                    Bandwidth = 1,
                },
            },
            ResourcePublicAccessDefaultEnabled = true,
        },
        PodsConfig = new Volcengine.Vke.Inputs.ClusterPodsConfigArgs
        {
            PodNetworkMode = "VpcCniShared",
            VpcCniConfig = new Volcengine.Vke.Inputs.ClusterPodsConfigVpcCniConfigArgs
            {
                SubnetIds = new[]
                {
                    fooSubnet.Id,
                },
            },
        },
        ServicesConfig = new Volcengine.Vke.Inputs.ClusterServicesConfigArgs
        {
            ServiceCidrsv4s = new[]
            {
                "172.30.0.0/18",
            },
        },
        Tags = new[]
        {
            new Volcengine.Vke.Inputs.ClusterTagArgs
            {
                Key = "tf-k1",
                Value = "tf-v1",
            },
        },
    });

    var fooNodePool = new List<Volcengine.Vke.NodePool>();
    for (var rangeIndex = 0; rangeIndex < 3; rangeIndex++)
    {
        var range = new { Value = rangeIndex };
        fooNodePool.Add(new Volcengine.Vke.NodePool($"fooNodePool-{range.Value}", new()
        {
            ClusterId = fooCluster.Id,
            AutoScaling = new Volcengine.Vke.Inputs.NodePoolAutoScalingArgs
            {
                Enabled = true,
                MinReplicas = 0,
                MaxReplicas = 5,
                DesiredReplicas = 0,
                Priority = 5,
                SubnetPolicy = "ZoneBalance",
            },
            NodeConfig = new Volcengine.Vke.Inputs.NodePoolNodeConfigArgs
            {
                InstanceTypeIds = new[]
                {
                    "ecs.g1ie.xlarge",
                },
                SubnetIds = new[]
                {
                    fooSubnet.Id,
                },
                ImageId = .Where(image => image.ImageName == "veLinux 1.0 CentOS兼容版 64位").Select(image => 
                {
                    return image.ImageId;
                }).ToList()[0],
                SystemVolume = new Volcengine.Vke.Inputs.NodePoolNodeConfigSystemVolumeArgs
                {
                    Type = "ESSD_PL0",
                    Size = 60,
                },
                DataVolumes = new[]
                {
                    new Volcengine.Vke.Inputs.NodePoolNodeConfigDataVolumeArgs
                    {
                        Type = "ESSD_PL0",
                        Size = 60,
                        MountPoint = "/tf1",
                    },
                    new Volcengine.Vke.Inputs.NodePoolNodeConfigDataVolumeArgs
                    {
                        Type = "ESSD_PL0",
                        Size = 60,
                        MountPoint = "/tf2",
                    },
                },
                InitializeScript = "ZWNobyBoZWxsbyB0ZXJyYWZvcm0h",
                Security = new Volcengine.Vke.Inputs.NodePoolNodeConfigSecurityArgs
                {
                    Login = new Volcengine.Vke.Inputs.NodePoolNodeConfigSecurityLoginArgs
                    {
                        Password = "UHdkMTIzNDU2",
                    },
                    SecurityStrategies = new[]
                    {
                        "Hids",
                    },
                    SecurityGroupIds = new[]
                    {
                        fooSecurityGroup.Id,
                    },
                },
                AdditionalContainerStorageEnabled = true,
                InstanceChargeType = "PostPaid",
                NamePrefix = "acc-test",
                EcsTags = new[]
                {
                    new Volcengine.Vke.Inputs.NodePoolNodeConfigEcsTagArgs
                    {
                        Key = "ecs_k1",
                        Value = "ecs_v1",
                    },
                },
            },
            KubernetesConfig = new Volcengine.Vke.Inputs.NodePoolKubernetesConfigArgs
            {
                Labels = new[]
                {
                    new Volcengine.Vke.Inputs.NodePoolKubernetesConfigLabelArgs
                    {
                        Key = "label1",
                        Value = "value1",
                    },
                },
                Taints = new[]
                {
                    new Volcengine.Vke.Inputs.NodePoolKubernetesConfigTaintArgs
                    {
                        Key = "taint-key/node-type",
                        Value = "taint-value",
                        Effect = "NoSchedule",
                    },
                },
                Cordon = true,
            },
            Tags = new[]
            {
                new Volcengine.Vke.Inputs.NodePoolTagArgs
                {
                    Key = "node-pool-k1",
                    Value = "node-pool-v1",
                },
            },
        }));
    }
    var fooNodePools = Volcengine.Vke.NodePools.Invoke(new()
    {
        Ids = fooNodePool.Select(__item => __item.Id).ToList(),
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.volcengine.ecs.EcsFunctions;
import com.pulumi.volcengine.ecs.inputs.ZonesArgs;
import com.pulumi.volcengine.vpc.Vpc;
import com.pulumi.volcengine.vpc.VpcArgs;
import com.pulumi.volcengine.vpc.Subnet;
import com.pulumi.volcengine.vpc.SubnetArgs;
import com.pulumi.volcengine.vpc.SecurityGroup;
import com.pulumi.volcengine.vpc.SecurityGroupArgs;
import com.pulumi.volcengine.ecs.inputs.ImagesArgs;
import com.pulumi.volcengine.vke.Cluster;
import com.pulumi.volcengine.vke.ClusterArgs;
import com.pulumi.volcengine.vke.inputs.ClusterClusterConfigArgs;
import com.pulumi.volcengine.vke.inputs.ClusterClusterConfigApiServerPublicAccessConfigArgs;
import com.pulumi.volcengine.vke.inputs.ClusterClusterConfigApiServerPublicAccessConfigPublicAccessNetworkConfigArgs;
import com.pulumi.volcengine.vke.inputs.ClusterPodsConfigArgs;
import com.pulumi.volcengine.vke.inputs.ClusterPodsConfigVpcCniConfigArgs;
import com.pulumi.volcengine.vke.inputs.ClusterServicesConfigArgs;
import com.pulumi.volcengine.vke.inputs.ClusterTagArgs;
import com.pulumi.volcengine.vke.NodePool;
import com.pulumi.volcengine.vke.NodePoolArgs;
import com.pulumi.volcengine.vke.inputs.NodePoolAutoScalingArgs;
import com.pulumi.volcengine.vke.inputs.NodePoolNodeConfigArgs;
import com.pulumi.volcengine.vke.inputs.NodePoolNodeConfigSystemVolumeArgs;
import com.pulumi.volcengine.vke.inputs.NodePoolNodeConfigSecurityArgs;
import com.pulumi.volcengine.vke.inputs.NodePoolNodeConfigSecurityLoginArgs;
import com.pulumi.volcengine.vke.inputs.NodePoolKubernetesConfigArgs;
import com.pulumi.volcengine.vke.inputs.NodePoolTagArgs;
import com.pulumi.volcengine.vke.VkeFunctions;
import com.pulumi.volcengine.vke.inputs.NodePoolsArgs;
import com.pulumi.codegen.internal.KeyedValue;
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 fooZones = EcsFunctions.Zones();

        var fooVpc = new Vpc("fooVpc", VpcArgs.builder()        
            .vpcName("acc-test-vpc")
            .cidrBlock("172.16.0.0/16")
            .build());

        var fooSubnet = new Subnet("fooSubnet", SubnetArgs.builder()        
            .subnetName("acc-test-subnet")
            .cidrBlock("172.16.0.0/24")
            .zoneId(fooZones.applyValue(zonesResult -> zonesResult.zones()[0].id()))
            .vpcId(fooVpc.id())
            .build());

        var fooSecurityGroup = new SecurityGroup("fooSecurityGroup", SecurityGroupArgs.builder()        
            .securityGroupName("acc-test-security-group")
            .vpcId(fooVpc.id())
            .build());

        final var fooImages = EcsFunctions.Images(ImagesArgs.builder()
            .nameRegex("veLinux 1.0 CentOS兼容版 64位")
            .build());

        var fooCluster = new Cluster("fooCluster", ClusterArgs.builder()        
            .description("created by terraform")
            .deleteProtectionEnabled(false)
            .clusterConfig(ClusterClusterConfigArgs.builder()
                .subnetIds(fooSubnet.id())
                .apiServerPublicAccessEnabled(true)
                .apiServerPublicAccessConfig(ClusterClusterConfigApiServerPublicAccessConfigArgs.builder()
                    .publicAccessNetworkConfig(ClusterClusterConfigApiServerPublicAccessConfigPublicAccessNetworkConfigArgs.builder()
                        .billingType("PostPaidByBandwidth")
                        .bandwidth(1)
                        .build())
                    .build())
                .resourcePublicAccessDefaultEnabled(true)
                .build())
            .podsConfig(ClusterPodsConfigArgs.builder()
                .podNetworkMode("VpcCniShared")
                .vpcCniConfig(ClusterPodsConfigVpcCniConfigArgs.builder()
                    .subnetIds(fooSubnet.id())
                    .build())
                .build())
            .servicesConfig(ClusterServicesConfigArgs.builder()
                .serviceCidrsv4s("172.30.0.0/18")
                .build())
            .tags(ClusterTagArgs.builder()
                .key("tf-k1")
                .value("tf-v1")
                .build())
            .build());

        for (var i = 0; i < 3; i++) {
            new NodePool("fooNodePool-" + i, NodePoolArgs.builder()            
                .clusterId(fooCluster.id())
                .autoScaling(NodePoolAutoScalingArgs.builder()
                    .enabled(true)
                    .minReplicas(0)
                    .maxReplicas(5)
                    .desiredReplicas(0)
                    .priority(5)
                    .subnetPolicy("ZoneBalance")
                    .build())
                .nodeConfig(NodePoolNodeConfigArgs.builder()
                    .instanceTypeIds("ecs.g1ie.xlarge")
                    .subnetIds(fooSubnet.id())
                    .imageId("TODO: ForExpression"[0])
                    .systemVolume(NodePoolNodeConfigSystemVolumeArgs.builder()
                        .type("ESSD_PL0")
                        .size("60")
                        .build())
                    .dataVolumes(                    
                        NodePoolNodeConfigDataVolumeArgs.builder()
                            .type("ESSD_PL0")
                            .size("60")
                            .mountPoint("/tf1")
                            .build(),
                        NodePoolNodeConfigDataVolumeArgs.builder()
                            .type("ESSD_PL0")
                            .size("60")
                            .mountPoint("/tf2")
                            .build())
                    .initializeScript("ZWNobyBoZWxsbyB0ZXJyYWZvcm0h")
                    .security(NodePoolNodeConfigSecurityArgs.builder()
                        .login(NodePoolNodeConfigSecurityLoginArgs.builder()
                            .password("UHdkMTIzNDU2")
                            .build())
                        .securityStrategies("Hids")
                        .securityGroupIds(fooSecurityGroup.id())
                        .build())
                    .additionalContainerStorageEnabled(true)
                    .instanceChargeType("PostPaid")
                    .namePrefix("acc-test")
                    .ecsTags(NodePoolNodeConfigEcsTagArgs.builder()
                        .key("ecs_k1")
                        .value("ecs_v1")
                        .build())
                    .build())
                .kubernetesConfig(NodePoolKubernetesConfigArgs.builder()
                    .labels(NodePoolKubernetesConfigLabelArgs.builder()
                        .key("label1")
                        .value("value1")
                        .build())
                    .taints(NodePoolKubernetesConfigTaintArgs.builder()
                        .key("taint-key/node-type")
                        .value("taint-value")
                        .effect("NoSchedule")
                        .build())
                    .cordon(true)
                    .build())
                .tags(NodePoolTagArgs.builder()
                    .key("node-pool-k1")
                    .value("node-pool-v1")
                    .build())
                .build());

        
}
        final var fooNodePools = VkeFunctions.NodePools(NodePoolsArgs.builder()
            .ids(fooNodePool.stream().map(element -> element.id()).collect(toList()))
            .build());

    }
}

function nodePools(args: NodePoolsArgs, opts?: InvokeOptions): Promise<NodePoolsResult>
function nodePoolsOutput(args: NodePoolsOutputArgs, opts?: InvokeOptions): Output<NodePoolsResult>

def node_pools(auto_scaling_enabled: Optional[bool] = None,
               cluster_id: Optional[str] = None,
               cluster_ids: Optional[Sequence[str]] = None,
               create_client_token: Optional[str] = None,
               ids: Optional[Sequence[str]] = None,
               name: Optional[str] = None,
               name_regex: Optional[str] = None,
               output_file: Optional[str] = None,
               statuses: Optional[Sequence[NodePoolsStatus]] = None,
               tags: Optional[Sequence[NodePoolsTag]] = None,
               update_client_token: Optional[str] = None,
               opts: Optional[InvokeOptions] = None) -> NodePoolsResult
def node_pools_output(auto_scaling_enabled: Optional[pulumi.Input[bool]] = None,
               cluster_id: Optional[pulumi.Input[str]] = None,
               cluster_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
               create_client_token: Optional[pulumi.Input[str]] = None,
               ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
               name: Optional[pulumi.Input[str]] = None,
               name_regex: Optional[pulumi.Input[str]] = None,
               output_file: Optional[pulumi.Input[str]] = None,
               statuses: Optional[pulumi.Input[Sequence[pulumi.Input[NodePoolsStatusArgs]]]] = None,
               tags: Optional[pulumi.Input[Sequence[pulumi.Input[NodePoolsTagArgs]]]] = None,
               update_client_token: Optional[pulumi.Input[str]] = None,
               opts: Optional[InvokeOptions] = None) -> Output[NodePoolsResult]

func NodePools(ctx *Context, args *NodePoolsArgs, opts ...InvokeOption) (*NodePoolsResult, error)
func NodePoolsOutput(ctx *Context, args *NodePoolsOutputArgs, opts ...InvokeOption) NodePoolsResultOutput

public static class NodePools 
{
    public static Task<NodePoolsResult> InvokeAsync(NodePoolsArgs args, InvokeOptions? opts = null)
    public static Output<NodePoolsResult> Invoke(NodePoolsInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<NodePoolsResult> nodePools(NodePoolsArgs args, InvokeOptions options)
public static Output<NodePoolsResult> nodePools(NodePoolsArgs args, InvokeOptions options)

fn::invoke:
  function: volcengine:vke:NodePools
  arguments:
    # arguments dictionary