Docs Home Pulumi IaC Pulumi ESC Pulumi Insights Pulumi Cloud Packages Tutorials
  1. Packages
  2. Ionoscloud
  3. API Docs
  4. dsaas
  5. NodePool
IonosCloud v0.2.3 published on Tuesday, May 13, 2025 by ionos-cloud
ionos-cloud/pulumi-ionoscloud

ionoscloud.dsaas.NodePool

Explore with Pulumi AI

ionoscloud logo
IonosCloud v0.2.3 published on Tuesday, May 13, 2025 by ionos-cloud
ionos-cloud/pulumi-ionoscloud

    Example Usage

    import * as pulumi from "@pulumi/pulumi";
import * as ionoscloud from "@ionos-cloud/sdk-pulumi";

const example = new ionoscloud.compute.Datacenter("example", {
    name: "Datacenter_Example",
    location: "de/txl",
    description: "Datacenter for testing Dataplatform Cluster",
});
const exampleCluster = new ionoscloud.dsaas.Cluster("example", {
    datacenterId: example.id,
    name: "Dataplatform_Cluster_Example",
    maintenanceWindows: [{
        dayOfTheWeek: "Sunday",
        time: "09:00:00",
    }],
    version: "23.7",
});
const exampleNodePool = new ionoscloud.dsaas.NodePool("example", {
    clusterId: exampleCluster.id,
    name: "Dataplatform_Node_Pool_Example",
    nodeCount: 1,
    cpuFamily: "INTEL_SKYLAKE",
    coresCount: 1,
    ramSize: 2048,
    availabilityZone: "AUTO",
    storageType: "HDD",
    storageSize: 10,
    maintenanceWindows: [{
        dayOfTheWeek: "Monday",
        time: "09:00:00",
    }],
    labels: {
        foo: "bar",
        color: "green",
    },
    annotations: {
        ann1: "value1",
        ann2: "value2",
    },
});

    import pulumi
import pulumi_ionoscloud as ionoscloud

example = ionoscloud.compute.Datacenter("example",
    name="Datacenter_Example",
    location="de/txl",
    description="Datacenter for testing Dataplatform Cluster")
example_cluster = ionoscloud.dsaas.Cluster("example",
    datacenter_id=example.id,
    name="Dataplatform_Cluster_Example",
    maintenance_windows=[{
        "day_of_the_week": "Sunday",
        "time": "09:00:00",
    }],
    version="23.7")
example_node_pool = ionoscloud.dsaas.NodePool("example",
    cluster_id=example_cluster.id,
    name="Dataplatform_Node_Pool_Example",
    node_count=1,
    cpu_family="INTEL_SKYLAKE",
    cores_count=1,
    ram_size=2048,
    availability_zone="AUTO",
    storage_type="HDD",
    storage_size=10,
    maintenance_windows=[{
        "day_of_the_week": "Monday",
        "time": "09:00:00",
    }],
    labels={
        "foo": "bar",
        "color": "green",
    },
    annotations={
        "ann1": "value1",
        "ann2": "value2",
    })

    package main

import (
	"github.com/ionos-cloud/pulumi-ionoscloud/sdk/go/ionoscloud/compute"
	"github.com/ionos-cloud/pulumi-ionoscloud/sdk/go/ionoscloud/dsaas"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := compute.NewDatacenter(ctx, "example", &compute.DatacenterArgs{
			Name:        pulumi.String("Datacenter_Example"),
			Location:    pulumi.String("de/txl"),
			Description: pulumi.String("Datacenter for testing Dataplatform Cluster"),
		})
		if err != nil {
			return err
		}
		exampleCluster, err := dsaas.NewCluster(ctx, "example", &dsaas.ClusterArgs{
			DatacenterId: example.ID(),
			Name:         pulumi.String("Dataplatform_Cluster_Example"),
			MaintenanceWindows: dsaas.ClusterMaintenanceWindowArray{
				&dsaas.ClusterMaintenanceWindowArgs{
					DayOfTheWeek: pulumi.String("Sunday"),
					Time:         pulumi.String("09:00:00"),
				},
			},
			Version: pulumi.String("23.7"),
		})
		if err != nil {
			return err
		}
		_, err = dsaas.NewNodePool(ctx, "example", &dsaas.NodePoolArgs{
			ClusterId:        exampleCluster.ID(),
			Name:             pulumi.String("Dataplatform_Node_Pool_Example"),
			NodeCount:        pulumi.Int(1),
			CpuFamily:        pulumi.String("INTEL_SKYLAKE"),
			CoresCount:       pulumi.Int(1),
			RamSize:          pulumi.Int(2048),
			AvailabilityZone: pulumi.String("AUTO"),
			StorageType:      pulumi.String("HDD"),
			StorageSize:      pulumi.Int(10),
			MaintenanceWindows: dsaas.NodePoolMaintenanceWindowArray{
				&dsaas.NodePoolMaintenanceWindowArgs{
					DayOfTheWeek: pulumi.String("Monday"),
					Time:         pulumi.String("09:00:00"),
				},
			},
			Labels: pulumi.StringMap{
				"foo":   pulumi.String("bar"),
				"color": pulumi.String("green"),
			},
			Annotations: pulumi.StringMap{
				"ann1": pulumi.String("value1"),
				"ann2": pulumi.String("value2"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var example = new Ionoscloud.Compute.Datacenter("example", new()
    {
        Name = "Datacenter_Example",
        Location = "de/txl",
        Description = "Datacenter for testing Dataplatform Cluster",
    });

    var exampleCluster = new Ionoscloud.Dsaas.Cluster("example", new()
    {
        DatacenterId = example.Id,
        Name = "Dataplatform_Cluster_Example",
        MaintenanceWindows = new[]
        {
            new Ionoscloud.Dsaas.Inputs.ClusterMaintenanceWindowArgs
            {
                DayOfTheWeek = "Sunday",
                Time = "09:00:00",
            },
        },
        Version = "23.7",
    });

    var exampleNodePool = new Ionoscloud.Dsaas.NodePool("example", new()
    {
        ClusterId = exampleCluster.Id,
        Name = "Dataplatform_Node_Pool_Example",
        NodeCount = 1,
        CpuFamily = "INTEL_SKYLAKE",
        CoresCount = 1,
        RamSize = 2048,
        AvailabilityZone = "AUTO",
        StorageType = "HDD",
        StorageSize = 10,
        MaintenanceWindows = new[]
        {
            new Ionoscloud.Dsaas.Inputs.NodePoolMaintenanceWindowArgs
            {
                DayOfTheWeek = "Monday",
                Time = "09:00:00",
            },
        },
        Labels = 
        {
            { "foo", "bar" },
            { "color", "green" },
        },
        Annotations = 
        {
            { "ann1", "value1" },
            { "ann2", "value2" },
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.ionoscloud.compute.Datacenter;
import com.pulumi.ionoscloud.compute.DatacenterArgs;
import com.pulumi.ionoscloud.dsaas.Cluster;
import com.pulumi.ionoscloud.dsaas.ClusterArgs;
import com.pulumi.ionoscloud.dsaas.inputs.ClusterMaintenanceWindowArgs;
import com.pulumi.ionoscloud.dsaas.NodePool;
import com.pulumi.ionoscloud.dsaas.NodePoolArgs;
import com.pulumi.ionoscloud.dsaas.inputs.NodePoolMaintenanceWindowArgs;
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) {
        var example = new Datacenter("example", DatacenterArgs.builder()
            .name("Datacenter_Example")
            .location("de/txl")
            .description("Datacenter for testing Dataplatform Cluster")
            .build());

        var exampleCluster = new Cluster("exampleCluster", ClusterArgs.builder()
            .datacenterId(example.id())
            .name("Dataplatform_Cluster_Example")
            .maintenanceWindows(ClusterMaintenanceWindowArgs.builder()
                .dayOfTheWeek("Sunday")
                .time("09:00:00")
                .build())
            .version("23.7")
            .build());

        var exampleNodePool = new NodePool("exampleNodePool", NodePoolArgs.builder()
            .clusterId(exampleCluster.id())
            .name("Dataplatform_Node_Pool_Example")
            .nodeCount(1)
            .cpuFamily("INTEL_SKYLAKE")
            .coresCount(1)
            .ramSize(2048)
            .availabilityZone("AUTO")
            .storageType("HDD")
            .storageSize(10)
            .maintenanceWindows(NodePoolMaintenanceWindowArgs.builder()
                .dayOfTheWeek("Monday")
                .time("09:00:00")
                .build())
            .labels(Map.ofEntries(
                Map.entry("foo", "bar"),
                Map.entry("color", "green")
            ))
            .annotations(Map.ofEntries(
                Map.entry("ann1", "value1"),
                Map.entry("ann2", "value2")
            ))
            .build());

    }
}

    resources:
  example:
    type: ionoscloud:compute:Datacenter
    properties:
      name: Datacenter_Example
      location: de/txl
      description: Datacenter for testing Dataplatform Cluster
  exampleCluster:
    type: ionoscloud:dsaas:Cluster
    name: example
    properties:
      datacenterId: ${example.id}
      name: Dataplatform_Cluster_Example
      maintenanceWindows:
        - dayOfTheWeek: Sunday
          time: 09:00:00
      version: '23.7'
  exampleNodePool:
    type: ionoscloud:dsaas:NodePool
    name: example
    properties:
      clusterId: ${exampleCluster.id}
      name: Dataplatform_Node_Pool_Example
      nodeCount: 1
      cpuFamily: INTEL_SKYLAKE
      coresCount: 1
      ramSize: 2048
      availabilityZone: AUTO
      storageType: HDD
      storageSize: 10
      maintenanceWindows:
        - dayOfTheWeek: Monday
          time: 09:00:00
      labels:
        foo: bar
        color: green
      annotations:
        ann1: value1
        ann2: value2

    Create NodePool Resource

    Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

    Constructor syntax

    new NodePool(name: string, args: NodePoolArgs, opts?: CustomResourceOptions);
    @overload
def NodePool(resource_name: str,
             args: NodePoolArgs,
             opts: Optional[ResourceOptions] = None)

@overload
def NodePool(resource_name: str,
             opts: Optional[ResourceOptions] = None,
             node_count: Optional[int] = None,
             cluster_id: Optional[str] = None,
             auto_scaling: Optional[NodePoolAutoScalingArgs] = None,
             availability_zone: Optional[str] = None,
             cores_count: Optional[int] = None,
             cpu_family: Optional[str] = None,
             labels: Optional[Mapping[str, str]] = None,
             maintenance_windows: Optional[Sequence[NodePoolMaintenanceWindowArgs]] = None,
             name: Optional[str] = None,
             annotations: Optional[Mapping[str, str]] = None,
             ram_size: Optional[int] = None,
             storage_size: Optional[int] = None,
             storage_type: Optional[str] = None)
    func NewNodePool(ctx *Context, name string, args NodePoolArgs, opts ...ResourceOption) (*NodePool, error)
    public NodePool(string name, NodePoolArgs args, CustomResourceOptions? opts = null)
    public NodePool(String name, NodePoolArgs args)
public NodePool(String name, NodePoolArgs args, CustomResourceOptions options)

    type: ionoscloud:dsaas:NodePool
properties: # The arguments to resource properties.
options: # Bag of options to control resource's behavior.

    Parameters

    name string
    The unique name of the resource.
    args NodePoolArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    resource_name str
    The unique name of the resource.
    args NodePoolArgs
    The arguments to resource properties.
    opts ResourceOptions
    Bag of options to control resource's behavior.
    ctx Context
    Context object for the current deployment.
    name string
    The unique name of the resource.
    args NodePoolArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args NodePoolArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args NodePoolArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    Constructor example

    The following reference example uses placeholder values for all input properties.

    var nodePoolResource = new Ionoscloud.Dsaas.NodePool("nodePoolResource", new()
{
    NodeCount = 0,
    ClusterId = "string",
    AutoScaling = new Ionoscloud.Dsaas.Inputs.NodePoolAutoScalingArgs
    {
        MaxNodeCount = 0,
        MinNodeCount = 0,
    },
    AvailabilityZone = "string",
    CoresCount = 0,
    CpuFamily = "string",
    Labels = 
    {
        { "string", "string" },
    },
    MaintenanceWindows = new[]
    {
        new Ionoscloud.Dsaas.Inputs.NodePoolMaintenanceWindowArgs
        {
            DayOfTheWeek = "string",
            Time = "string",
        },
    },
    Name = "string",
    Annotations = 
    {
        { "string", "string" },
    },
    RamSize = 0,
    StorageSize = 0,
    StorageType = "string",
});

    example, err := dsaas.NewNodePool(ctx, "nodePoolResource", &dsaas.NodePoolArgs{
	NodeCount: pulumi.Int(0),
	ClusterId: pulumi.String("string"),
	AutoScaling: &dsaas.NodePoolAutoScalingArgs{
		MaxNodeCount: pulumi.Int(0),
		MinNodeCount: pulumi.Int(0),
	},
	AvailabilityZone: pulumi.String("string"),
	CoresCount:       pulumi.Int(0),
	CpuFamily:        pulumi.String("string"),
	Labels: pulumi.StringMap{
		"string": pulumi.String("string"),
	},
	MaintenanceWindows: dsaas.NodePoolMaintenanceWindowArray{
		&dsaas.NodePoolMaintenanceWindowArgs{
			DayOfTheWeek: pulumi.String("string"),
			Time:         pulumi.String("string"),
		},
	},
	Name: pulumi.String("string"),
	Annotations: pulumi.StringMap{
		"string": pulumi.String("string"),
	},
	RamSize:     pulumi.Int(0),
	StorageSize: pulumi.Int(0),
	StorageType: pulumi.String("string"),
})

    var nodePoolResource = new com.ionoscloud.pulumi.ionoscloud.dsaas.NodePool("nodePoolResource", com.ionoscloud.pulumi.ionoscloud.dsaas.NodePoolArgs.builder()
    .nodeCount(0)
    .clusterId("string")
    .autoScaling(NodePoolAutoScalingArgs.builder()
        .maxNodeCount(0)
        .minNodeCount(0)
        .build())
    .availabilityZone("string")
    .coresCount(0)
    .cpuFamily("string")
    .labels(Map.of("string", "string"))
    .maintenanceWindows(NodePoolMaintenanceWindowArgs.builder()
        .dayOfTheWeek("string")
        .time("string")
        .build())
    .name("string")
    .annotations(Map.of("string", "string"))
    .ramSize(0)
    .storageSize(0)
    .storageType("string")
    .build());

    node_pool_resource = ionoscloud.dsaas.NodePool("nodePoolResource",
    node_count=0,
    cluster_id="string",
    auto_scaling={
        "max_node_count": 0,
        "min_node_count": 0,
    },
    availability_zone="string",
    cores_count=0,
    cpu_family="string",
    labels={
        "string": "string",
    },
    maintenance_windows=[{
        "day_of_the_week": "string",
        "time": "string",
    }],
    name="string",
    annotations={
        "string": "string",
    },
    ram_size=0,
    storage_size=0,
    storage_type="string")

    const nodePoolResource = new ionoscloud.dsaas.NodePool("nodePoolResource", {
    nodeCount: 0,
    clusterId: "string",
    autoScaling: {
        maxNodeCount: 0,
        minNodeCount: 0,
    },
    availabilityZone: "string",
    coresCount: 0,
    cpuFamily: "string",
    labels: {
        string: "string",
    },
    maintenanceWindows: [{
        dayOfTheWeek: "string",
        time: "string",
    }],
    name: "string",
    annotations: {
        string: "string",
    },
    ramSize: 0,
    storageSize: 0,
    storageType: "string",
});

    type: ionoscloud:dsaas:NodePool
properties:
    annotations:
        string: string
    autoScaling:
        maxNodeCount: 0
        minNodeCount: 0
    availabilityZone: string
    clusterId: string
    coresCount: 0
    cpuFamily: string
    labels:
        string: string
    maintenanceWindows:
        - dayOfTheWeek: string
          time: string
    name: string
    nodeCount: 0
    ramSize: 0
    storageSize: 0
    storageType: string

    NodePool Resource Properties

    To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

    Inputs

    In Python, inputs that are objects can be passed either as argument classes or as dictionary literals.

    The NodePool resource accepts the following input properties:

    ClusterId string
    [string] The UUID of an existing Dataplatform cluster.
    NodeCount int
    [int] The number of nodes that make up the node pool. Must be set with a minimum value of 1.
    Annotations Dictionary<string, string>
    [map] Key-value pairs attached to node pool resource as Kubernetes annotations.
    AutoScaling Ionoscloud.NodePoolAutoScaling
    [string] Whether the Node Pool should autoscale. For more details, please check the API documentation
    AvailabilityZone string
    [string] The availability zone of the virtual datacenter region where the node pool resources should be provisioned. Must be set with one of the values AUTO, ZONE_1 or ZONE_2. The default value is AUTO.
    CoresCount int
    [int] The number of CPU cores per node. Must be set with a minimum value of 1. The default value is 4.
    CpuFamily string
    [string] A valid CPU family name or AUTO if the platform shall choose the best fitting option. Available CPU architectures can be retrieved from the datacenter resource. The default value is AUTO.
    Labels Dictionary<string, string>
    [map] Key-value pairs attached to the node pool resource as Kubernetes labels.
    MaintenanceWindows List<Ionoscloud.NodePoolMaintenanceWindow>
    Starting time of a weekly 4 hour-long window, during which maintenance might occur in hh:mm:ss format
    Name string
    [string] The name of your node pool. Must be 63 characters or less and must be empty or begin and end with an alphanumeric character ([a-z0-9A-Z]). It can contain dashes (-), underscores (_), dots (.), and alphanumerics in-between.
    RamSize int
    [int] The RAM size for one node in MB. Must be set in multiples of 1024MB, with a minimum size is of 2048MB. The default value is 4096.
    StorageSize int
    [int] The size of the volume in GB. The size must be greater than 10GB. The default value is 20.
    StorageType string
    [int] The type of hardware for the volume. Must be set with one of the values HDD or SSD. The default value is SSD.
    ClusterId string
    [string] The UUID of an existing Dataplatform cluster.
    NodeCount int
    [int] The number of nodes that make up the node pool. Must be set with a minimum value of 1.
    Annotations map[string]string
    [map] Key-value pairs attached to node pool resource as Kubernetes annotations.
    AutoScaling NodePoolAutoScalingArgs
    [string] Whether the Node Pool should autoscale. For more details, please check the API documentation
    AvailabilityZone string
    [string] The availability zone of the virtual datacenter region where the node pool resources should be provisioned. Must be set with one of the values AUTO, ZONE_1 or ZONE_2. The default value is AUTO.
    CoresCount int
    [int] The number of CPU cores per node. Must be set with a minimum value of 1. The default value is 4.
    CpuFamily string
    [string] A valid CPU family name or AUTO if the platform shall choose the best fitting option. Available CPU architectures can be retrieved from the datacenter resource. The default value is AUTO.
    Labels map[string]string
    [map] Key-value pairs attached to the node pool resource as Kubernetes labels.
    MaintenanceWindows []NodePoolMaintenanceWindowArgs
    Starting time of a weekly 4 hour-long window, during which maintenance might occur in hh:mm:ss format
    Name string
    [string] The name of your node pool. Must be 63 characters or less and must be empty or begin and end with an alphanumeric character ([a-z0-9A-Z]). It can contain dashes (-), underscores (_), dots (.), and alphanumerics in-between.
    RamSize int
    [int] The RAM size for one node in MB. Must be set in multiples of 1024MB, with a minimum size is of 2048MB. The default value is 4096.
    StorageSize int
    [int] The size of the volume in GB. The size must be greater than 10GB. The default value is 20.
    StorageType string
    [int] The type of hardware for the volume. Must be set with one of the values HDD or SSD. The default value is SSD.
    clusterId String
    [string] The UUID of an existing Dataplatform cluster.
    nodeCount Integer
    [int] The number of nodes that make up the node pool. Must be set with a minimum value of 1.
    annotations Map<String,String>
    [map] Key-value pairs attached to node pool resource as Kubernetes annotations.
    autoScaling NodePoolAutoScaling
    [string] Whether the Node Pool should autoscale. For more details, please check the API documentation
    availabilityZone String
    [string] The availability zone of the virtual datacenter region where the node pool resources should be provisioned. Must be set with one of the values AUTO, ZONE_1 or ZONE_2. The default value is AUTO.
    coresCount Integer
    [int] The number of CPU cores per node. Must be set with a minimum value of 1. The default value is 4.
    cpuFamily String
    [string] A valid CPU family name or AUTO if the platform shall choose the best fitting option. Available CPU architectures can be retrieved from the datacenter resource. The default value is AUTO.
    labels Map<String,String>
    [map] Key-value pairs attached to the node pool resource as Kubernetes labels.
    maintenanceWindows List<NodePoolMaintenanceWindow>
    Starting time of a weekly 4 hour-long window, during which maintenance might occur in hh:mm:ss format
    name String
    [string] The name of your node pool. Must be 63 characters or less and must be empty or begin and end with an alphanumeric character ([a-z0-9A-Z]). It can contain dashes (-), underscores (_), dots (.), and alphanumerics in-between.
    ramSize Integer
    [int] The RAM size for one node in MB. Must be set in multiples of 1024MB, with a minimum size is of 2048MB. The default value is 4096.
    storageSize Integer
    [int] The size of the volume in GB. The size must be greater than 10GB. The default value is 20.
    storageType String
    [int] The type of hardware for the volume. Must be set with one of the values HDD or SSD. The default value is SSD.
    clusterId string
    [string] The UUID of an existing Dataplatform cluster.
    nodeCount number
    [int] The number of nodes that make up the node pool. Must be set with a minimum value of 1.
    annotations {[key: string]: string}
    [map] Key-value pairs attached to node pool resource as Kubernetes annotations.
    autoScaling NodePoolAutoScaling
    [string] Whether the Node Pool should autoscale. For more details, please check the API documentation
    availabilityZone string
    [string] The availability zone of the virtual datacenter region where the node pool resources should be provisioned. Must be set with one of the values AUTO, ZONE_1 or ZONE_2. The default value is AUTO.
    coresCount number
    [int] The number of CPU cores per node. Must be set with a minimum value of 1. The default value is 4.
    cpuFamily string
    [string] A valid CPU family name or AUTO if the platform shall choose the best fitting option. Available CPU architectures can be retrieved from the datacenter resource. The default value is AUTO.
    labels {[key: string]: string}
    [map] Key-value pairs attached to the node pool resource as Kubernetes labels.
    maintenanceWindows NodePoolMaintenanceWindow[]
    Starting time of a weekly 4 hour-long window, during which maintenance might occur in hh:mm:ss format
    name string
    [string] The name of your node pool. Must be 63 characters or less and must be empty or begin and end with an alphanumeric character ([a-z0-9A-Z]). It can contain dashes (-), underscores (_), dots (.), and alphanumerics in-between.
    ramSize number
    [int] The RAM size for one node in MB. Must be set in multiples of 1024MB, with a minimum size is of 2048MB. The default value is 4096.
    storageSize number
    [int] The size of the volume in GB. The size must be greater than 10GB. The default value is 20.
    storageType string
    [int] The type of hardware for the volume. Must be set with one of the values HDD or SSD. The default value is SSD.
    cluster_id str
    [string] The UUID of an existing Dataplatform cluster.
    node_count int
    [int] The number of nodes that make up the node pool. Must be set with a minimum value of 1.
    annotations Mapping[str, str]
    [map] Key-value pairs attached to node pool resource as Kubernetes annotations.
    auto_scaling NodePoolAutoScalingArgs
    [string] Whether the Node Pool should autoscale. For more details, please check the API documentation
    availability_zone str
    [string] The availability zone of the virtual datacenter region where the node pool resources should be provisioned. Must be set with one of the values AUTO, ZONE_1 or ZONE_2. The default value is AUTO.
    cores_count int
    [int] The number of CPU cores per node. Must be set with a minimum value of 1. The default value is 4.
    cpu_family str
    [string] A valid CPU family name or AUTO if the platform shall choose the best fitting option. Available CPU architectures can be retrieved from the datacenter resource. The default value is AUTO.
    labels Mapping[str, str]
    [map] Key-value pairs attached to the node pool resource as Kubernetes labels.
    maintenance_windows Sequence[NodePoolMaintenanceWindowArgs]
    Starting time of a weekly 4 hour-long window, during which maintenance might occur in hh:mm:ss format
    name str
    [string] The name of your node pool. Must be 63 characters or less and must be empty or begin and end with an alphanumeric character ([a-z0-9A-Z]). It can contain dashes (-), underscores (_), dots (.), and alphanumerics in-between.
    ram_size int
    [int] The RAM size for one node in MB. Must be set in multiples of 1024MB, with a minimum size is of 2048MB. The default value is 4096.
    storage_size int
    [int] The size of the volume in GB. The size must be greater than 10GB. The default value is 20.
    storage_type str
    [int] The type of hardware for the volume. Must be set with one of the values HDD or SSD. The default value is SSD.
    clusterId String
    [string] The UUID of an existing Dataplatform cluster.
    nodeCount Number
    [int] The number of nodes that make up the node pool. Must be set with a minimum value of 1.
    annotations Map<String>
    [map] Key-value pairs attached to node pool resource as Kubernetes annotations.
    autoScaling Property Map
    [string] Whether the Node Pool should autoscale. For more details, please check the API documentation
    availabilityZone String
    [string] The availability zone of the virtual datacenter region where the node pool resources should be provisioned. Must be set with one of the values AUTO, ZONE_1 or ZONE_2. The default value is AUTO.
    coresCount Number
    [int] The number of CPU cores per node. Must be set with a minimum value of 1. The default value is 4.
    cpuFamily String
    [string] A valid CPU family name or AUTO if the platform shall choose the best fitting option. Available CPU architectures can be retrieved from the datacenter resource. The default value is AUTO.
    labels Map<String>
    [map] Key-value pairs attached to the node pool resource as Kubernetes labels.
    maintenanceWindows List<Property Map>
    Starting time of a weekly 4 hour-long window, during which maintenance might occur in hh:mm:ss format
    name String
    [string] The name of your node pool. Must be 63 characters or less and must be empty or begin and end with an alphanumeric character ([a-z0-9A-Z]). It can contain dashes (-), underscores (_), dots (.), and alphanumerics in-between.
    ramSize Number
    [int] The RAM size for one node in MB. Must be set in multiples of 1024MB, with a minimum size is of 2048MB. The default value is 4096.
    storageSize Number
    [int] The size of the volume in GB. The size must be greater than 10GB. The default value is 20.
    storageType String
    [int] The type of hardware for the volume. Must be set with one of the values HDD or SSD. The default value is SSD.

    Outputs

    All input properties are implicitly available as output properties. Additionally, the NodePool resource produces the following output properties:

    DatacenterId string
    The UUID of the virtual data center (VDC) in which the nodepool is provisioned
    Id string
    The provider-assigned unique ID for this managed resource.
    Version string
    The version of the Data Platform.
    DatacenterId string
    The UUID of the virtual data center (VDC) in which the nodepool is provisioned
    Id string
    The provider-assigned unique ID for this managed resource.
    Version string
    The version of the Data Platform.
    datacenterId String
    The UUID of the virtual data center (VDC) in which the nodepool is provisioned
    id String
    The provider-assigned unique ID for this managed resource.
    version String
    The version of the Data Platform.
    datacenterId string
    The UUID of the virtual data center (VDC) in which the nodepool is provisioned
    id string
    The provider-assigned unique ID for this managed resource.
    version string
    The version of the Data Platform.
    datacenter_id str
    The UUID of the virtual data center (VDC) in which the nodepool is provisioned
    id str
    The provider-assigned unique ID for this managed resource.
    version str
    The version of the Data Platform.
    datacenterId String
    The UUID of the virtual data center (VDC) in which the nodepool is provisioned
    id String
    The provider-assigned unique ID for this managed resource.
    version String
    The version of the Data Platform.

    Look up Existing NodePool Resource

    Get an existing NodePool resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

    public static get(name: string, id: Input<ID>, state?: NodePoolState, opts?: CustomResourceOptions): NodePool
    @staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        annotations: Optional[Mapping[str, str]] = None,
        auto_scaling: Optional[NodePoolAutoScalingArgs] = None,
        availability_zone: Optional[str] = None,
        cluster_id: Optional[str] = None,
        cores_count: Optional[int] = None,
        cpu_family: Optional[str] = None,
        datacenter_id: Optional[str] = None,
        labels: Optional[Mapping[str, str]] = None,
        maintenance_windows: Optional[Sequence[NodePoolMaintenanceWindowArgs]] = None,
        name: Optional[str] = None,
        node_count: Optional[int] = None,
        ram_size: Optional[int] = None,
        storage_size: Optional[int] = None,
        storage_type: Optional[str] = None,
        version: Optional[str] = None) -> NodePool
    func GetNodePool(ctx *Context, name string, id IDInput, state *NodePoolState, opts ...ResourceOption) (*NodePool, error)
    public static NodePool Get(string name, Input<string> id, NodePoolState? state, CustomResourceOptions? opts = null)
    public static NodePool get(String name, Output<String> id, NodePoolState state, CustomResourceOptions options)
    resources:  _:    type: ionoscloud:dsaas:NodePool    get:      id: ${id}
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    resource_name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    The following state arguments are supported:
    Annotations Dictionary<string, string>
    [map] Key-value pairs attached to node pool resource as Kubernetes annotations.
    AutoScaling Ionoscloud.NodePoolAutoScaling
    [string] Whether the Node Pool should autoscale. For more details, please check the API documentation
    AvailabilityZone string
    [string] The availability zone of the virtual datacenter region where the node pool resources should be provisioned. Must be set with one of the values AUTO, ZONE_1 or ZONE_2. The default value is AUTO.
    ClusterId string
    [string] The UUID of an existing Dataplatform cluster.
    CoresCount int
    [int] The number of CPU cores per node. Must be set with a minimum value of 1. The default value is 4.
    CpuFamily string
    [string] A valid CPU family name or AUTO if the platform shall choose the best fitting option. Available CPU architectures can be retrieved from the datacenter resource. The default value is AUTO.
    DatacenterId string
    The UUID of the virtual data center (VDC) in which the nodepool is provisioned
    Labels Dictionary<string, string>
    [map] Key-value pairs attached to the node pool resource as Kubernetes labels.
    MaintenanceWindows List<Ionoscloud.NodePoolMaintenanceWindow>
    Starting time of a weekly 4 hour-long window, during which maintenance might occur in hh:mm:ss format
    Name string
    [string] The name of your node pool. Must be 63 characters or less and must be empty or begin and end with an alphanumeric character ([a-z0-9A-Z]). It can contain dashes (-), underscores (_), dots (.), and alphanumerics in-between.
    NodeCount int
    [int] The number of nodes that make up the node pool. Must be set with a minimum value of 1.
    RamSize int
    [int] The RAM size for one node in MB. Must be set in multiples of 1024MB, with a minimum size is of 2048MB. The default value is 4096.
    StorageSize int
    [int] The size of the volume in GB. The size must be greater than 10GB. The default value is 20.
    StorageType string
    [int] The type of hardware for the volume. Must be set with one of the values HDD or SSD. The default value is SSD.
    Version string
    The version of the Data Platform.
    Annotations map[string]string
    [map] Key-value pairs attached to node pool resource as Kubernetes annotations.
    AutoScaling NodePoolAutoScalingArgs
    [string] Whether the Node Pool should autoscale. For more details, please check the API documentation
    AvailabilityZone string
    [string] The availability zone of the virtual datacenter region where the node pool resources should be provisioned. Must be set with one of the values AUTO, ZONE_1 or ZONE_2. The default value is AUTO.
    ClusterId string
    [string] The UUID of an existing Dataplatform cluster.
    CoresCount int
    [int] The number of CPU cores per node. Must be set with a minimum value of 1. The default value is 4.
    CpuFamily string
    [string] A valid CPU family name or AUTO if the platform shall choose the best fitting option. Available CPU architectures can be retrieved from the datacenter resource. The default value is AUTO.
    DatacenterId string
    The UUID of the virtual data center (VDC) in which the nodepool is provisioned
    Labels map[string]string
    [map] Key-value pairs attached to the node pool resource as Kubernetes labels.
    MaintenanceWindows []NodePoolMaintenanceWindowArgs
    Starting time of a weekly 4 hour-long window, during which maintenance might occur in hh:mm:ss format
    Name string
    [string] The name of your node pool. Must be 63 characters or less and must be empty or begin and end with an alphanumeric character ([a-z0-9A-Z]). It can contain dashes (-), underscores (_), dots (.), and alphanumerics in-between.
    NodeCount int
    [int] The number of nodes that make up the node pool. Must be set with a minimum value of 1.
    RamSize int
    [int] The RAM size for one node in MB. Must be set in multiples of 1024MB, with a minimum size is of 2048MB. The default value is 4096.
    StorageSize int
    [int] The size of the volume in GB. The size must be greater than 10GB. The default value is 20.
    StorageType string
    [int] The type of hardware for the volume. Must be set with one of the values HDD or SSD. The default value is SSD.
    Version string
    The version of the Data Platform.
    annotations Map<String,String>
    [map] Key-value pairs attached to node pool resource as Kubernetes annotations.
    autoScaling NodePoolAutoScaling
    [string] Whether the Node Pool should autoscale. For more details, please check the API documentation
    availabilityZone String
    [string] The availability zone of the virtual datacenter region where the node pool resources should be provisioned. Must be set with one of the values AUTO, ZONE_1 or ZONE_2. The default value is AUTO.
    clusterId String
    [string] The UUID of an existing Dataplatform cluster.
    coresCount Integer
    [int] The number of CPU cores per node. Must be set with a minimum value of 1. The default value is 4.
    cpuFamily String
    [string] A valid CPU family name or AUTO if the platform shall choose the best fitting option. Available CPU architectures can be retrieved from the datacenter resource. The default value is AUTO.
    datacenterId String
    The UUID of the virtual data center (VDC) in which the nodepool is provisioned
    labels Map<String,String>
    [map] Key-value pairs attached to the node pool resource as Kubernetes labels.
    maintenanceWindows List<NodePoolMaintenanceWindow>
    Starting time of a weekly 4 hour-long window, during which maintenance might occur in hh:mm:ss format
    name String
    [string] The name of your node pool. Must be 63 characters or less and must be empty or begin and end with an alphanumeric character ([a-z0-9A-Z]). It can contain dashes (-), underscores (_), dots (.), and alphanumerics in-between.
    nodeCount Integer
    [int] The number of nodes that make up the node pool. Must be set with a minimum value of 1.
    ramSize Integer
    [int] The RAM size for one node in MB. Must be set in multiples of 1024MB, with a minimum size is of 2048MB. The default value is 4096.
    storageSize Integer
    [int] The size of the volume in GB. The size must be greater than 10GB. The default value is 20.
    storageType String
    [int] The type of hardware for the volume. Must be set with one of the values HDD or SSD. The default value is SSD.
    version String
    The version of the Data Platform.
    annotations {[key: string]: string}
    [map] Key-value pairs attached to node pool resource as Kubernetes annotations.
    autoScaling NodePoolAutoScaling
    [string] Whether the Node Pool should autoscale. For more details, please check the API documentation
    availabilityZone string
    [string] The availability zone of the virtual datacenter region where the node pool resources should be provisioned. Must be set with one of the values AUTO, ZONE_1 or ZONE_2. The default value is AUTO.
    clusterId string
    [string] The UUID of an existing Dataplatform cluster.
    coresCount number
    [int] The number of CPU cores per node. Must be set with a minimum value of 1. The default value is 4.
    cpuFamily string
    [string] A valid CPU family name or AUTO if the platform shall choose the best fitting option. Available CPU architectures can be retrieved from the datacenter resource. The default value is AUTO.
    datacenterId string
    The UUID of the virtual data center (VDC) in which the nodepool is provisioned
    labels {[key: string]: string}
    [map] Key-value pairs attached to the node pool resource as Kubernetes labels.
    maintenanceWindows NodePoolMaintenanceWindow[]
    Starting time of a weekly 4 hour-long window, during which maintenance might occur in hh:mm:ss format
    name string
    [string] The name of your node pool. Must be 63 characters or less and must be empty or begin and end with an alphanumeric character ([a-z0-9A-Z]). It can contain dashes (-), underscores (_), dots (.), and alphanumerics in-between.
    nodeCount number
    [int] The number of nodes that make up the node pool. Must be set with a minimum value of 1.
    ramSize number
    [int] The RAM size for one node in MB. Must be set in multiples of 1024MB, with a minimum size is of 2048MB. The default value is 4096.
    storageSize number
    [int] The size of the volume in GB. The size must be greater than 10GB. The default value is 20.
    storageType string
    [int] The type of hardware for the volume. Must be set with one of the values HDD or SSD. The default value is SSD.
    version string
    The version of the Data Platform.
    annotations Mapping[str, str]
    [map] Key-value pairs attached to node pool resource as Kubernetes annotations.
    auto_scaling NodePoolAutoScalingArgs
    [string] Whether the Node Pool should autoscale. For more details, please check the API documentation
    availability_zone str
    [string] The availability zone of the virtual datacenter region where the node pool resources should be provisioned. Must be set with one of the values AUTO, ZONE_1 or ZONE_2. The default value is AUTO.
    cluster_id str
    [string] The UUID of an existing Dataplatform cluster.
    cores_count int
    [int] The number of CPU cores per node. Must be set with a minimum value of 1. The default value is 4.
    cpu_family str
    [string] A valid CPU family name or AUTO if the platform shall choose the best fitting option. Available CPU architectures can be retrieved from the datacenter resource. The default value is AUTO.
    datacenter_id str
    The UUID of the virtual data center (VDC) in which the nodepool is provisioned
    labels Mapping[str, str]
    [map] Key-value pairs attached to the node pool resource as Kubernetes labels.
    maintenance_windows Sequence[NodePoolMaintenanceWindowArgs]
    Starting time of a weekly 4 hour-long window, during which maintenance might occur in hh:mm:ss format
    name str
    [string] The name of your node pool. Must be 63 characters or less and must be empty or begin and end with an alphanumeric character ([a-z0-9A-Z]). It can contain dashes (-), underscores (_), dots (.), and alphanumerics in-between.
    node_count int
    [int] The number of nodes that make up the node pool. Must be set with a minimum value of 1.
    ram_size int
    [int] The RAM size for one node in MB. Must be set in multiples of 1024MB, with a minimum size is of 2048MB. The default value is 4096.
    storage_size int
    [int] The size of the volume in GB. The size must be greater than 10GB. The default value is 20.
    storage_type str
    [int] The type of hardware for the volume. Must be set with one of the values HDD or SSD. The default value is SSD.
    version str
    The version of the Data Platform.
    annotations Map<String>
    [map] Key-value pairs attached to node pool resource as Kubernetes annotations.
    autoScaling Property Map
    [string] Whether the Node Pool should autoscale. For more details, please check the API documentation
    availabilityZone String
    [string] The availability zone of the virtual datacenter region where the node pool resources should be provisioned. Must be set with one of the values AUTO, ZONE_1 or ZONE_2. The default value is AUTO.
    clusterId String
    [string] The UUID of an existing Dataplatform cluster.
    coresCount Number
    [int] The number of CPU cores per node. Must be set with a minimum value of 1. The default value is 4.
    cpuFamily String
    [string] A valid CPU family name or AUTO if the platform shall choose the best fitting option. Available CPU architectures can be retrieved from the datacenter resource. The default value is AUTO.
    datacenterId String
    The UUID of the virtual data center (VDC) in which the nodepool is provisioned
    labels Map<String>
    [map] Key-value pairs attached to the node pool resource as Kubernetes labels.
    maintenanceWindows List<Property Map>
    Starting time of a weekly 4 hour-long window, during which maintenance might occur in hh:mm:ss format
    name String
    [string] The name of your node pool. Must be 63 characters or less and must be empty or begin and end with an alphanumeric character ([a-z0-9A-Z]). It can contain dashes (-), underscores (_), dots (.), and alphanumerics in-between.
    nodeCount Number
    [int] The number of nodes that make up the node pool. Must be set with a minimum value of 1.
    ramSize Number
    [int] The RAM size for one node in MB. Must be set in multiples of 1024MB, with a minimum size is of 2048MB. The default value is 4096.
    storageSize Number
    [int] The size of the volume in GB. The size must be greater than 10GB. The default value is 20.
    storageType String
    [int] The type of hardware for the volume. Must be set with one of the values HDD or SSD. The default value is SSD.
    version String
    The version of the Data Platform.

    Supporting Types

    NodePoolAutoScaling, NodePoolAutoScalingArgs

    MaxNodeCount int
    [int] The maximum number of worker nodes that the node pool can scale to. Should be greater than min_node_count
    MinNodeCount int
    [int] The minimum number of worker nodes the node pool can scale down to. Should be less than max_node_count
    MaxNodeCount int
    [int] The maximum number of worker nodes that the node pool can scale to. Should be greater than min_node_count
    MinNodeCount int
    [int] The minimum number of worker nodes the node pool can scale down to. Should be less than max_node_count
    maxNodeCount Integer
    [int] The maximum number of worker nodes that the node pool can scale to. Should be greater than min_node_count
    minNodeCount Integer
    [int] The minimum number of worker nodes the node pool can scale down to. Should be less than max_node_count
    maxNodeCount number
    [int] The maximum number of worker nodes that the node pool can scale to. Should be greater than min_node_count
    minNodeCount number
    [int] The minimum number of worker nodes the node pool can scale down to. Should be less than max_node_count
    max_node_count int
    [int] The maximum number of worker nodes that the node pool can scale to. Should be greater than min_node_count
    min_node_count int
    [int] The minimum number of worker nodes the node pool can scale down to. Should be less than max_node_count
    maxNodeCount Number
    [int] The maximum number of worker nodes that the node pool can scale to. Should be greater than min_node_count
    minNodeCount Number
    [int] The minimum number of worker nodes the node pool can scale down to. Should be less than max_node_count

    NodePoolMaintenanceWindow, NodePoolMaintenanceWindowArgs

    DayOfTheWeek string
    [string] Must be set with one the values Monday, Tuesday, Wednesday, Thursday, Friday, Saturday or Sunday.
    Time string
    [string] Time at which the maintenance should start. Must conform to the 'HH:MM:SS' 24-hour format. This pattern matches the "HH:MM:SS 24-hour format with leading 0" format. For more information take a look at this link.
    DayOfTheWeek string
    [string] Must be set with one the values Monday, Tuesday, Wednesday, Thursday, Friday, Saturday or Sunday.
    Time string
    [string] Time at which the maintenance should start. Must conform to the 'HH:MM:SS' 24-hour format. This pattern matches the "HH:MM:SS 24-hour format with leading 0" format. For more information take a look at this link.
    dayOfTheWeek String
    [string] Must be set with one the values Monday, Tuesday, Wednesday, Thursday, Friday, Saturday or Sunday.
    time String
    [string] Time at which the maintenance should start. Must conform to the 'HH:MM:SS' 24-hour format. This pattern matches the "HH:MM:SS 24-hour format with leading 0" format. For more information take a look at this link.
    dayOfTheWeek string
    [string] Must be set with one the values Monday, Tuesday, Wednesday, Thursday, Friday, Saturday or Sunday.
    time string
    [string] Time at which the maintenance should start. Must conform to the 'HH:MM:SS' 24-hour format. This pattern matches the "HH:MM:SS 24-hour format with leading 0" format. For more information take a look at this link.
    day_of_the_week str
    [string] Must be set with one the values Monday, Tuesday, Wednesday, Thursday, Friday, Saturday or Sunday.
    time str
    [string] Time at which the maintenance should start. Must conform to the 'HH:MM:SS' 24-hour format. This pattern matches the "HH:MM:SS 24-hour format with leading 0" format. For more information take a look at this link.
    dayOfTheWeek String
    [string] Must be set with one the values Monday, Tuesday, Wednesday, Thursday, Friday, Saturday or Sunday.
    time String
    [string] Time at which the maintenance should start. Must conform to the 'HH:MM:SS' 24-hour format. This pattern matches the "HH:MM:SS 24-hour format with leading 0" format. For more information take a look at this link.

    Import

    A Dataplatform Node Pool resource can be imported using its cluster’s UUID as well as its own UUID, e.g.:

    $ pulumi import ionoscloud:dsaas/nodePool:NodePool mynodepool dataplatform_cluster_uuid/dataplatform_nodepool_id

    To learn more about importing existing cloud resources, see Importing resources.

    Package Details

    Repository
    ionoscloud ionos-cloud/pulumi-ionoscloud
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the ionoscloud Terraform Provider.
    ionoscloud logo
    IonosCloud v0.2.3 published on Tuesday, May 13, 2025 by ionos-cloud
    ionos-cloud/pulumi-ionoscloud