1. Packages
  2. Volcengine
  3. API Docs
  4. vke
  5. Nodes
Volcengine v0.0.24 published on Tuesday, Jun 25, 2024 by Volcengine

volcengine.vke.Nodes

Explore with Pulumi AI

volcengine logo
Volcengine v0.0.24 published on Tuesday, Jun 25, 2024 by Volcengine

    Use this data source to query detailed information of vke nodes

    Example Usage

    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 = false,
            },
            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 = 50,
                },
                DataVolumes = new[]
                {
                    new Volcengine.Vke.Inputs.NodePoolNodeConfigDataVolumeArgs
                    {
                        Type = "ESSD_PL0",
                        Size = 50,
                        MountPoint = "/tf",
                    },
                },
                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 fooInstance = new List<Volcengine.Ecs.Instance>();
        for (var rangeIndex = 0; rangeIndex < 2; rangeIndex++)
        {
            var range = new { Value = rangeIndex };
            fooInstance.Add(new Volcengine.Ecs.Instance($"fooInstance-{range.Value}", new()
            {
                InstanceName = $"acc-test-ecs-{range.Value}",
                HostName = "tf-acc-test",
                ImageId = .Where(image => image.ImageName == "veLinux 1.0 CentOS兼容版 64位").Select(image => 
                {
                    return  image.ImageId;
                })[0],
                InstanceType = "ecs.g1ie.xlarge",
                Password = "93f0cb0614Aab12",
                InstanceChargeType = "PostPaid",
                SystemVolumeType = "ESSD_PL0",
                SystemVolumeSize = 50,
                DataVolumes = new[]
                {
                    new Volcengine.Ecs.Inputs.InstanceDataVolumeArgs
                    {
                        VolumeType = "ESSD_PL0",
                        Size = 50,
                        DeleteWithInstance = true,
                    },
                },
                SubnetId = fooSubnet.Id,
                SecurityGroupIds = new[]
                {
                    fooSecurityGroup.Id,
                },
                ProjectName = "default",
                Tags = new[]
                {
                    new Volcengine.Ecs.Inputs.InstanceTagArgs
                    {
                        Key = "k1",
                        Value = "v1",
                    },
                },
            }));
        }
        var fooNode = new List<Volcengine.Vke.Node>();
        for (var rangeIndex = 0; rangeIndex < 2; rangeIndex++)
        {
            var range = new { Value = rangeIndex };
            fooNode.Add(new Volcengine.Vke.Node($"fooNode-{range.Value}", new()
            {
                ClusterId = fooCluster.Id,
                InstanceId = fooInstance[range.Value].Id,
                NodePoolId = fooNodePool.Id,
            }));
        }
        var fooNodes = Volcengine.Vke.Nodes.Invoke(new()
        {
            Ids = fooNode.Select(__item => __item.Id).ToList(),
        });
    
    });
    
    package main
    
    import (
    	"fmt"
    
    	"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
    }
    fooNodePool, err := vke.NewNodePool(ctx, "fooNodePool", &vke.NodePoolArgs{
    ClusterId: fooCluster.ID(),
    AutoScaling: &vke.NodePoolAutoScalingArgs{
    Enabled: pulumi.Bool(false),
    },
    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(50),
    },
    DataVolumes: vke.NodePoolNodeConfigDataVolumeArray{
    &vke.NodePoolNodeConfigDataVolumeArgs{
    Type: pulumi.String("ESSD_PL0"),
    Size: pulumi.Int(50),
    MountPoint: pulumi.String("/tf"),
    },
    },
    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
    }
    var fooInstance []*ecs.Instance
    for index := 0; index < 2; index++ {
        key0 := index
        val0 := index
    __res, err := ecs.NewInstance(ctx, fmt.Sprintf("fooInstance-%v", key0), &ecs.InstanceArgs{
    InstanceName: pulumi.String(fmt.Sprintf("acc-test-ecs-%v", val0)),
    HostName: pulumi.String("tf-acc-test"),
    ImageId: "TODO: For expression"[0],
    InstanceType: pulumi.String("ecs.g1ie.xlarge"),
    Password: pulumi.String("93f0cb0614Aab12"),
    InstanceChargeType: pulumi.String("PostPaid"),
    SystemVolumeType: pulumi.String("ESSD_PL0"),
    SystemVolumeSize: pulumi.Int(50),
    DataVolumes: ecs.InstanceDataVolumeArray{
    &ecs.InstanceDataVolumeArgs{
    VolumeType: pulumi.String("ESSD_PL0"),
    Size: pulumi.Int(50),
    DeleteWithInstance: pulumi.Bool(true),
    },
    },
    SubnetId: fooSubnet.ID(),
    SecurityGroupIds: pulumi.StringArray{
    fooSecurityGroup.ID(),
    },
    ProjectName: pulumi.String("default"),
    Tags: ecs.InstanceTagArray{
    &ecs.InstanceTagArgs{
    Key: pulumi.String("k1"),
    Value: pulumi.String("v1"),
    },
    },
    })
    if err != nil {
    return err
    }
    fooInstance = append(fooInstance, __res)
    }
    var fooNode []*vke.Node
    for index := 0; index < 2; index++ {
        key0 := index
        val0 := index
    __res, err := vke.NewNode(ctx, fmt.Sprintf("fooNode-%v", key0), &vke.NodeArgs{
    ClusterId: fooCluster.ID(),
    InstanceId: fooInstance[val0].ID(),
    NodePoolId: fooNodePool.ID(),
    })
    if err != nil {
    return err
    }
    fooNode = append(fooNode, __res)
    }
    _ = vke.NodesOutput(ctx, vke.NodesOutputArgs{
    Ids: %!v(PANIC=Format method: fatal: A failure has occurred: unlowered splat expression @ #-functions-volcengine:vke-nodes:Nodes.pp:134,9-22),
    }, nil);
    return nil
    })
    }
    

    Coming soon!

    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=False,
        ),
        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=50,
            ),
            data_volumes=[volcengine.vke.NodePoolNodeConfigDataVolumeArgs(
                type="ESSD_PL0",
                size=50,
                mount_point="/tf",
            )],
            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_instance = []
    for range in [{"value": i} for i in range(0, 2)]:
        foo_instance.append(volcengine.ecs.Instance(f"fooInstance-{range['value']}",
            instance_name=f"acc-test-ecs-{range['value']}",
            host_name="tf-acc-test",
            image_id=[image.image_id for image in foo_images.images if image.image_name == "veLinux 1.0 CentOS兼容版 64位"][0],
            instance_type="ecs.g1ie.xlarge",
            password="93f0cb0614Aab12",
            instance_charge_type="PostPaid",
            system_volume_type="ESSD_PL0",
            system_volume_size=50,
            data_volumes=[volcengine.ecs.InstanceDataVolumeArgs(
                volume_type="ESSD_PL0",
                size=50,
                delete_with_instance=True,
            )],
            subnet_id=foo_subnet.id,
            security_group_ids=[foo_security_group.id],
            project_name="default",
            tags=[volcengine.ecs.InstanceTagArgs(
                key="k1",
                value="v1",
            )]))
    foo_node = []
    for range in [{"value": i} for i in range(0, 2)]:
        foo_node.append(volcengine.vke.Node(f"fooNode-{range['value']}",
            cluster_id=foo_cluster.id,
            instance_id=foo_instance[range["value"]].id,
            node_pool_id=foo_node_pool.id))
    foo_nodes = volcengine.vke.nodes_output(ids=[__item.id for __item in foo_node])
    
    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: false,
        },
        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: 50,
            },
            dataVolumes: [{
                type: "ESSD_PL0",
                size: 50,
                mountPoint: "/tf",
            }],
            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 fooInstance: volcengine.ecs.Instance[] = [];
    for (const range = {value: 0}; range.value < 2; range.value++) {
        fooInstance.push(new volcengine.ecs.Instance(`fooInstance-${range.value}`, {
            instanceName: `acc-test-ecs-${range.value}`,
            hostName: "tf-acc-test",
            imageId: fooImages.then(fooImages => .filter(image => image.imageName == "veLinux 1.0 CentOS兼容版 64位").map(image => (image.imageId))[0]),
            instanceType: "ecs.g1ie.xlarge",
            password: "93f0cb0614Aab12",
            instanceChargeType: "PostPaid",
            systemVolumeType: "ESSD_PL0",
            systemVolumeSize: 50,
            dataVolumes: [{
                volumeType: "ESSD_PL0",
                size: 50,
                deleteWithInstance: true,
            }],
            subnetId: fooSubnet.id,
            securityGroupIds: [fooSecurityGroup.id],
            projectName: "default",
            tags: [{
                key: "k1",
                value: "v1",
            }],
        }));
    }
    const fooNode: volcengine.vke.Node[] = [];
    for (const range = {value: 0}; range.value < 2; range.value++) {
        fooNode.push(new volcengine.vke.Node(`fooNode-${range.value}`, {
            clusterId: fooCluster.id,
            instanceId: fooInstance[range.value].id,
            nodePoolId: fooNodePool.id,
        }));
    }
    const fooNodes = volcengine.vke.NodesOutput({
        ids: fooNode.map(__item => __item.id),
    });
    

    Coming soon!

    Using Nodes

    Two invocation forms are available. The direct form accepts plain arguments and either blocks until the result value is available, or returns a Promise-wrapped result. The output form accepts Input-wrapped arguments and returns an Output-wrapped result.

    function nodes(args: NodesArgs, opts?: InvokeOptions): Promise<NodesResult>
    function nodesOutput(args: NodesOutputArgs, opts?: InvokeOptions): Output<NodesResult>
    def nodes(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,
              node_pool_ids: Optional[Sequence[str]] = None,
              output_file: Optional[str] = None,
              statuses: Optional[Sequence[NodesStatus]] = None,
              zone_ids: Optional[Sequence[str]] = None,
              opts: Optional[InvokeOptions] = None) -> NodesResult
    def nodes_output(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,
              node_pool_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
              output_file: Optional[pulumi.Input[str]] = None,
              statuses: Optional[pulumi.Input[Sequence[pulumi.Input[NodesStatusArgs]]]] = None,
              zone_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
              opts: Optional[InvokeOptions] = None) -> Output[NodesResult]
    func Nodes(ctx *Context, args *NodesArgs, opts ...InvokeOption) (*NodesResult, error)
    func NodesOutput(ctx *Context, args *NodesOutputArgs, opts ...InvokeOption) NodesResultOutput
    public static class Nodes 
    {
        public static Task<NodesResult> InvokeAsync(NodesArgs args, InvokeOptions? opts = null)
        public static Output<NodesResult> Invoke(NodesInvokeArgs args, InvokeOptions? opts = null)
    }
    public static CompletableFuture<NodesResult> nodes(NodesArgs args, InvokeOptions options)
    // Output-based functions aren't available in Java yet
    
    fn::invoke:
      function: volcengine:vke:Nodes
      arguments:
        # arguments dictionary

    The following arguments are supported:

    ClusterIds List<string>
    A list of Cluster IDs.
    CreateClientToken string
    The Create Client Token.
    Ids List<string>
    A list of Node IDs.
    Name string
    The Name of Node.
    NameRegex string
    A Name Regex of Node.
    NodePoolIds List<string>
    The Node Pool IDs.
    OutputFile string
    File name where to save data source results.
    Statuses List<NodesStatus>
    The Status of filter.
    ZoneIds List<string>
    The Zone IDs.
    ClusterIds []string
    A list of Cluster IDs.
    CreateClientToken string
    The Create Client Token.
    Ids []string
    A list of Node IDs.
    Name string
    The Name of Node.
    NameRegex string
    A Name Regex of Node.
    NodePoolIds []string
    The Node Pool IDs.
    OutputFile string
    File name where to save data source results.
    Statuses []NodesStatus
    The Status of filter.
    ZoneIds []string
    The Zone IDs.
    clusterIds List<String>
    A list of Cluster IDs.
    createClientToken String
    The Create Client Token.
    ids List<String>
    A list of Node IDs.
    name String
    The Name of Node.
    nameRegex String
    A Name Regex of Node.
    nodePoolIds List<String>
    The Node Pool IDs.
    outputFile String
    File name where to save data source results.
    statuses List<NodesStatus>
    The Status of filter.
    zoneIds List<String>
    The Zone IDs.
    clusterIds string[]
    A list of Cluster IDs.
    createClientToken string
    The Create Client Token.
    ids string[]
    A list of Node IDs.
    name string
    The Name of Node.
    nameRegex string
    A Name Regex of Node.
    nodePoolIds string[]
    The Node Pool IDs.
    outputFile string
    File name where to save data source results.
    statuses NodesStatus[]
    The Status of filter.
    zoneIds string[]
    The Zone IDs.
    cluster_ids Sequence[str]
    A list of Cluster IDs.
    create_client_token str
    The Create Client Token.
    ids Sequence[str]
    A list of Node IDs.
    name str
    The Name of Node.
    name_regex str
    A Name Regex of Node.
    node_pool_ids Sequence[str]
    The Node Pool IDs.
    output_file str
    File name where to save data source results.
    statuses Sequence[NodesStatus]
    The Status of filter.
    zone_ids Sequence[str]
    The Zone IDs.
    clusterIds List<String>
    A list of Cluster IDs.
    createClientToken String
    The Create Client Token.
    ids List<String>
    A list of Node IDs.
    name String
    The Name of Node.
    nameRegex String
    A Name Regex of Node.
    nodePoolIds List<String>
    The Node Pool IDs.
    outputFile String
    File name where to save data source results.
    statuses List<Property Map>
    The Status of filter.
    zoneIds List<String>
    The Zone IDs.

    Nodes Result

    The following output properties are available:

    Id string
    The provider-assigned unique ID for this managed resource.
    Nodes List<NodesNode>
    The collection of Node query.
    TotalCount int
    The total count of Node query.
    ClusterIds List<string>
    CreateClientToken string
    The create client token of node.
    Ids List<string>
    Name string
    The name of Node.
    NameRegex string
    NodePoolIds List<string>
    OutputFile string
    Statuses List<NodesStatus>
    ZoneIds List<string>
    Id string
    The provider-assigned unique ID for this managed resource.
    Nodes []NodesNode
    The collection of Node query.
    TotalCount int
    The total count of Node query.
    ClusterIds []string
    CreateClientToken string
    The create client token of node.
    Ids []string
    Name string
    The name of Node.
    NameRegex string
    NodePoolIds []string
    OutputFile string
    Statuses []NodesStatus
    ZoneIds []string
    id String
    The provider-assigned unique ID for this managed resource.
    nodes List<NodesNode>
    The collection of Node query.
    totalCount Integer
    The total count of Node query.
    clusterIds List<String>
    createClientToken String
    The create client token of node.
    ids List<String>
    name String
    The name of Node.
    nameRegex String
    nodePoolIds List<String>
    outputFile String
    statuses List<NodesStatus>
    zoneIds List<String>
    id string
    The provider-assigned unique ID for this managed resource.
    nodes NodesNode[]
    The collection of Node query.
    totalCount number
    The total count of Node query.
    clusterIds string[]
    createClientToken string
    The create client token of node.
    ids string[]
    name string
    The name of Node.
    nameRegex string
    nodePoolIds string[]
    outputFile string
    statuses NodesStatus[]
    zoneIds string[]
    id str
    The provider-assigned unique ID for this managed resource.
    nodes Sequence[NodesNode]
    The collection of Node query.
    total_count int
    The total count of Node query.
    cluster_ids Sequence[str]
    create_client_token str
    The create client token of node.
    ids Sequence[str]
    name str
    The name of Node.
    name_regex str
    node_pool_ids Sequence[str]
    output_file str
    statuses Sequence[NodesStatus]
    zone_ids Sequence[str]
    id String
    The provider-assigned unique ID for this managed resource.
    nodes List<Property Map>
    The collection of Node query.
    totalCount Number
    The total count of Node query.
    clusterIds List<String>
    createClientToken String
    The create client token of node.
    ids List<String>
    name String
    The name of Node.
    nameRegex String
    nodePoolIds List<String>
    outputFile String
    statuses List<Property Map>
    zoneIds List<String>

    Supporting Types

    NodesNode

    AdditionalContainerStorageEnabled bool
    Is Additional Container storage enables.
    ClusterId string
    The cluster id of node.
    ConditionTypes List<string>
    The Condition of Node.
    ContainerStoragePath string
    The Storage Path.
    Cordon bool
    The Cordon of KubernetesConfig.
    CreateClientToken string
    The Create Client Token.
    CreateTime string
    The create time of Node.
    Id string
    The ID of Node.
    ImageId string
    The ImageId of NodeConfig.
    InitializeScript string
    The InitializeScript of NodeConfig.
    InstanceId string
    The instance id of node.
    IsVirtual bool
    Is virtual node.
    Labels List<NodesNodeLabel>
    The Label of KubernetesConfig.
    Name string
    The Name of Node.
    NodePoolId string
    The node pool id.
    Phase string
    The Phase of Node, the value is Creating or Running or Updating or Deleting or Failed or Starting or Stopping or Stopped.
    Roles List<string>
    The roles of node.
    Taints List<NodesNodeTaint>
    The Taint of KubernetesConfig.
    UpdateTime string
    The update time of Node.
    ZoneId string
    The zone id.
    AdditionalContainerStorageEnabled bool
    Is Additional Container storage enables.
    ClusterId string
    The cluster id of node.
    ConditionTypes []string
    The Condition of Node.
    ContainerStoragePath string
    The Storage Path.
    Cordon bool
    The Cordon of KubernetesConfig.
    CreateClientToken string
    The Create Client Token.
    CreateTime string
    The create time of Node.
    Id string
    The ID of Node.
    ImageId string
    The ImageId of NodeConfig.
    InitializeScript string
    The InitializeScript of NodeConfig.
    InstanceId string
    The instance id of node.
    IsVirtual bool
    Is virtual node.
    Labels []NodesNodeLabel
    The Label of KubernetesConfig.
    Name string
    The Name of Node.
    NodePoolId string
    The node pool id.
    Phase string
    The Phase of Node, the value is Creating or Running or Updating or Deleting or Failed or Starting or Stopping or Stopped.
    Roles []string
    The roles of node.
    Taints []NodesNodeTaint
    The Taint of KubernetesConfig.
    UpdateTime string
    The update time of Node.
    ZoneId string
    The zone id.
    additionalContainerStorageEnabled Boolean
    Is Additional Container storage enables.
    clusterId String
    The cluster id of node.
    conditionTypes List<String>
    The Condition of Node.
    containerStoragePath String
    The Storage Path.
    cordon Boolean
    The Cordon of KubernetesConfig.
    createClientToken String
    The Create Client Token.
    createTime String
    The create time of Node.
    id String
    The ID of Node.
    imageId String
    The ImageId of NodeConfig.
    initializeScript String
    The InitializeScript of NodeConfig.
    instanceId String
    The instance id of node.
    isVirtual Boolean
    Is virtual node.
    labels List<NodesNodeLabel>
    The Label of KubernetesConfig.
    name String
    The Name of Node.
    nodePoolId String
    The node pool id.
    phase String
    The Phase of Node, the value is Creating or Running or Updating or Deleting or Failed or Starting or Stopping or Stopped.
    roles List<String>
    The roles of node.
    taints List<NodesNodeTaint>
    The Taint of KubernetesConfig.
    updateTime String
    The update time of Node.
    zoneId String
    The zone id.
    additionalContainerStorageEnabled boolean
    Is Additional Container storage enables.
    clusterId string
    The cluster id of node.
    conditionTypes string[]
    The Condition of Node.
    containerStoragePath string
    The Storage Path.
    cordon boolean
    The Cordon of KubernetesConfig.
    createClientToken string
    The Create Client Token.
    createTime string
    The create time of Node.
    id string
    The ID of Node.
    imageId string
    The ImageId of NodeConfig.
    initializeScript string
    The InitializeScript of NodeConfig.
    instanceId string
    The instance id of node.
    isVirtual boolean
    Is virtual node.
    labels NodesNodeLabel[]
    The Label of KubernetesConfig.
    name string
    The Name of Node.
    nodePoolId string
    The node pool id.
    phase string
    The Phase of Node, the value is Creating or Running or Updating or Deleting or Failed or Starting or Stopping or Stopped.
    roles string[]
    The roles of node.
    taints NodesNodeTaint[]
    The Taint of KubernetesConfig.
    updateTime string
    The update time of Node.
    zoneId string
    The zone id.
    additional_container_storage_enabled bool
    Is Additional Container storage enables.
    cluster_id str
    The cluster id of node.
    condition_types Sequence[str]
    The Condition of Node.
    container_storage_path str
    The Storage Path.
    cordon bool
    The Cordon of KubernetesConfig.
    create_client_token str
    The Create Client Token.
    create_time str
    The create time of Node.
    id str
    The ID of Node.
    image_id str
    The ImageId of NodeConfig.
    initialize_script str
    The InitializeScript of NodeConfig.
    instance_id str
    The instance id of node.
    is_virtual bool
    Is virtual node.
    labels Sequence[NodesNodeLabel]
    The Label of KubernetesConfig.
    name str
    The Name of Node.
    node_pool_id str
    The node pool id.
    phase str
    The Phase of Node, the value is Creating or Running or Updating or Deleting or Failed or Starting or Stopping or Stopped.
    roles Sequence[str]
    The roles of node.
    taints Sequence[NodesNodeTaint]
    The Taint of KubernetesConfig.
    update_time str
    The update time of Node.
    zone_id str
    The zone id.
    additionalContainerStorageEnabled Boolean
    Is Additional Container storage enables.
    clusterId String
    The cluster id of node.
    conditionTypes List<String>
    The Condition of Node.
    containerStoragePath String
    The Storage Path.
    cordon Boolean
    The Cordon of KubernetesConfig.
    createClientToken String
    The Create Client Token.
    createTime String
    The create time of Node.
    id String
    The ID of Node.
    imageId String
    The ImageId of NodeConfig.
    initializeScript String
    The InitializeScript of NodeConfig.
    instanceId String
    The instance id of node.
    isVirtual Boolean
    Is virtual node.
    labels List<Property Map>
    The Label of KubernetesConfig.
    name String
    The Name of Node.
    nodePoolId String
    The node pool id.
    phase String
    The Phase of Node, the value is Creating or Running or Updating or Deleting or Failed or Starting or Stopping or Stopped.
    roles List<String>
    The roles of node.
    taints List<Property Map>
    The Taint of KubernetesConfig.
    updateTime String
    The update time of Node.
    zoneId String
    The zone id.

    NodesNodeLabel

    Key string
    The Key of Taint.
    Value string
    The Value of Taint.
    Key string
    The Key of Taint.
    Value string
    The Value of Taint.
    key String
    The Key of Taint.
    value String
    The Value of Taint.
    key string
    The Key of Taint.
    value string
    The Value of Taint.
    key str
    The Key of Taint.
    value str
    The Value of Taint.
    key String
    The Key of Taint.
    value String
    The Value of Taint.

    NodesNodeTaint

    Effect string
    The Effect of Taint.
    Key string
    The Key of Taint.
    Value string
    The Value of Taint.
    Effect string
    The Effect of Taint.
    Key string
    The Key of Taint.
    Value string
    The Value of Taint.
    effect String
    The Effect of Taint.
    key String
    The Key of Taint.
    value String
    The Value of Taint.
    effect string
    The Effect of Taint.
    key string
    The Key of Taint.
    value string
    The Value of Taint.
    effect str
    The Effect of Taint.
    key str
    The Key of Taint.
    value str
    The Value of Taint.
    effect String
    The Effect of Taint.
    key String
    The Key of Taint.
    value String
    The Value of Taint.

    NodesStatus

    ConditionsType string
    The Type of Node Condition, the value is Progressing or Ok or Unschedulable or InitilizeFailed or Unknown or NotReady or Security or Balance or ResourceCleanupFailed.
    Phase string
    The Phase of Node, the value is Creating or Running or Updating or Deleting or Failed or Starting or Stopping or Stopped.
    ConditionsType string
    The Type of Node Condition, the value is Progressing or Ok or Unschedulable or InitilizeFailed or Unknown or NotReady or Security or Balance or ResourceCleanupFailed.
    Phase string
    The Phase of Node, the value is Creating or Running or Updating or Deleting or Failed or Starting or Stopping or Stopped.
    conditionsType String
    The Type of Node Condition, the value is Progressing or Ok or Unschedulable or InitilizeFailed or Unknown or NotReady or Security or Balance or ResourceCleanupFailed.
    phase String
    The Phase of Node, the value is Creating or Running or Updating or Deleting or Failed or Starting or Stopping or Stopped.
    conditionsType string
    The Type of Node Condition, the value is Progressing or Ok or Unschedulable or InitilizeFailed or Unknown or NotReady or Security or Balance or ResourceCleanupFailed.
    phase string
    The Phase of Node, the value is Creating or Running or Updating or Deleting or Failed or Starting or Stopping or Stopped.
    conditions_type str
    The Type of Node Condition, the value is Progressing or Ok or Unschedulable or InitilizeFailed or Unknown or NotReady or Security or Balance or ResourceCleanupFailed.
    phase str
    The Phase of Node, the value is Creating or Running or Updating or Deleting or Failed or Starting or Stopping or Stopped.
    conditionsType String
    The Type of Node Condition, the value is Progressing or Ok or Unschedulable or InitilizeFailed or Unknown or NotReady or Security or Balance or ResourceCleanupFailed.
    phase String
    The Phase of Node, the value is Creating or Running or Updating or Deleting or Failed or Starting or Stopping or Stopped.

    Package Details

    Repository
    volcengine volcengine/pulumi-volcengine
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the volcengine Terraform Provider.
    volcengine logo
    Volcengine v0.0.24 published on Tuesday, Jun 25, 2024 by Volcengine