volcengine.vke.NodePool

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 Volcengine.Vke.NodePool("fooNodePool", 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 = 80,
            },
            DataVolumes = new[]
            {
                new Volcengine.Vke.Inputs.NodePoolNodeConfigDataVolumeArgs
                {
                    Type = "ESSD_PL0",
                    Size = 80,
                    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 = false,
            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",
            },
        },
    });

});

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
		}
		_, err = vke.NewNodePool(ctx, "fooNodePool", &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(80),
				},
				DataVolumes: vke.NodePoolNodeConfigDataVolumeArray{
					&vke.NodePoolNodeConfigDataVolumeArgs{
						Type:       pulumi.String("ESSD_PL0"),
						Size:       pulumi.Int(80),
						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(false),
				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
		}
		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 = volcengine.vke.NodePool("fooNodePool",
    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=80,
        ),
        data_volumes=[
            volcengine.vke.NodePoolNodeConfigDataVolumeArgs(
                type="ESSD_PL0",
                size=80,
                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=False,
        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",
    )])

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 = new volcengine.vke.NodePool("fooNodePool", {
    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: 80,
        },
        dataVolumes: [
            {
                type: "ESSD_PL0",
                size: 80,
                mountPoint: "/tf1",
            },
            {
                type: "ESSD_PL0",
                size: 60,
                mountPoint: "/tf2",
            },
        ],
        initializeScript: "ZWNobyBoZWxsbyB0ZXJyYWZvcm0h",
        security: {
            login: {
                password: "UHdkMTIzNDU2",
            },
            securityStrategies: ["Hids"],
            securityGroupIds: [fooSecurityGroup.id],
        },
        additionalContainerStorageEnabled: false,
        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",
    }],
});