volcengine.vke.NodePools

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;
                })[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 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
})
}

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])

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),
});