ionoscloud.k8s.NodePool

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: "us/las",
    description: "datacenter description",
    secAuthProtection: false,
});
const exampleLan = new ionoscloud.compute.Lan("example", {
    datacenterId: example.id,
    "public": false,
    name: "Lan Example",
});
const exampleIPBlock = new ionoscloud.compute.IPBlock("example", {
    location: "us/las",
    size: 3,
    name: "IP Block Example",
});
const exampleCluster = new ionoscloud.k8s.Cluster("example", {
    name: "k8sClusterExample",
    k8sVersion: "1.31.2",
    maintenanceWindow: {
        dayOfTheWeek: "Sunday",
        time: "09:00:00Z",
    },
    apiSubnetAllowLists: ["1.2.3.4/32"],
    s3Buckets: [{
        name: "globally_unique_s3_bucket_name",
    }],
});
const exampleNodePool = new ionoscloud.k8s.NodePool("example", {
    datacenterId: example.id,
    k8sClusterId: exampleCluster.id,
    name: "k8sNodePoolExample",
    k8sVersion: exampleCluster.k8sVersion,
    maintenanceWindow: {
        dayOfTheWeek: "Monday",
        time: "09:00:00Z",
    },
    autoScaling: {
        minNodeCount: 1,
        maxNodeCount: 2,
    },
    cpuFamily: "INTEL_XEON",
    availabilityZone: "AUTO",
    storageType: "SSD",
    nodeCount: 1,
    coresCount: 2,
    ramSize: 2048,
    storageSize: 40,
    publicIps: [
        exampleIPBlock.ips[0],
        exampleIPBlock.ips[1],
        exampleIPBlock.ips[2],
    ],
    lans: [{
        id: exampleLan.id,
        dhcp: true,
        routes: [{
            network: "1.2.3.5/24",
            gatewayIp: "10.1.5.17",
        }],
    }],
    labels: {
        lab1: "value1",
        lab2: "value2",
    },
    annotations: {
        ann1: "value1",
        ann2: "value2",
    },
});

import pulumi
import pulumi_ionoscloud as ionoscloud

example = ionoscloud.compute.Datacenter("example",
    name="Datacenter Example",
    location="us/las",
    description="datacenter description",
    sec_auth_protection=False)
example_lan = ionoscloud.compute.Lan("example",
    datacenter_id=example.id,
    public=False,
    name="Lan Example")
example_ip_block = ionoscloud.compute.IPBlock("example",
    location="us/las",
    size=3,
    name="IP Block Example")
example_cluster = ionoscloud.k8s.Cluster("example",
    name="k8sClusterExample",
    k8s_version="1.31.2",
    maintenance_window={
        "day_of_the_week": "Sunday",
        "time": "09:00:00Z",
    },
    api_subnet_allow_lists=["1.2.3.4/32"],
    s3_buckets=[{
        "name": "globally_unique_s3_bucket_name",
    }])
example_node_pool = ionoscloud.k8s.NodePool("example",
    datacenter_id=example.id,
    k8s_cluster_id=example_cluster.id,
    name="k8sNodePoolExample",
    k8s_version=example_cluster.k8s_version,
    maintenance_window={
        "day_of_the_week": "Monday",
        "time": "09:00:00Z",
    },
    auto_scaling={
        "min_node_count": 1,
        "max_node_count": 2,
    },
    cpu_family="INTEL_XEON",
    availability_zone="AUTO",
    storage_type="SSD",
    node_count=1,
    cores_count=2,
    ram_size=2048,
    storage_size=40,
    public_ips=[
        example_ip_block.ips[0],
        example_ip_block.ips[1],
        example_ip_block.ips[2],
    ],
    lans=[{
        "id": example_lan.id,
        "dhcp": True,
        "routes": [{
            "network": "1.2.3.5/24",
            "gateway_ip": "10.1.5.17",
        }],
    }],
    labels={
        "lab1": "value1",
        "lab2": "value2",
    },
    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/k8s"
	"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("us/las"),
			Description:       pulumi.String("datacenter description"),
			SecAuthProtection: pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		exampleLan, err := compute.NewLan(ctx, "example", &compute.LanArgs{
			DatacenterId: example.ID(),
			Public:       pulumi.Bool(false),
			Name:         pulumi.String("Lan Example"),
		})
		if err != nil {
			return err
		}
		exampleIPBlock, err := compute.NewIPBlock(ctx, "example", &compute.IPBlockArgs{
			Location: pulumi.String("us/las"),
			Size:     pulumi.Int(3),
			Name:     pulumi.String("IP Block Example"),
		})
		if err != nil {
			return err
		}
		exampleCluster, err := k8s.NewCluster(ctx, "example", &k8s.ClusterArgs{
			Name:       pulumi.String("k8sClusterExample"),
			K8sVersion: pulumi.String("1.31.2"),
			MaintenanceWindow: &k8s.ClusterMaintenanceWindowArgs{
				DayOfTheWeek: pulumi.String("Sunday"),
				Time:         pulumi.String("09:00:00Z"),
			},
			ApiSubnetAllowLists: pulumi.StringArray{
				pulumi.String("1.2.3.4/32"),
			},
			S3Buckets: k8s.ClusterS3BucketArray{
				&k8s.ClusterS3BucketArgs{
					Name: pulumi.String("globally_unique_s3_bucket_name"),
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = k8s.NewNodePool(ctx, "example", &k8s.NodePoolArgs{
			DatacenterId: example.ID(),
			K8sClusterId: exampleCluster.ID(),
			Name:         pulumi.String("k8sNodePoolExample"),
			K8sVersion:   exampleCluster.K8sVersion,
			MaintenanceWindow: &k8s.NodePoolMaintenanceWindowArgs{
				DayOfTheWeek: pulumi.String("Monday"),
				Time:         pulumi.String("09:00:00Z"),
			},
			AutoScaling: &k8s.NodePoolAutoScalingArgs{
				MinNodeCount: pulumi.Int(1),
				MaxNodeCount: pulumi.Int(2),
			},
			CpuFamily:        pulumi.String("INTEL_XEON"),
			AvailabilityZone: pulumi.String("AUTO"),
			StorageType:      pulumi.String("SSD"),
			NodeCount:        pulumi.Int(1),
			CoresCount:       pulumi.Int(2),
			RamSize:          pulumi.Int(2048),
			StorageSize:      pulumi.Int(40),
			PublicIps: pulumi.StringArray{
				exampleIPBlock.Ips.ApplyT(func(ips []string) (string, error) {
					return ips[0], nil
				}).(pulumi.StringOutput),
				exampleIPBlock.Ips.ApplyT(func(ips []string) (string, error) {
					return ips[1], nil
				}).(pulumi.StringOutput),
				exampleIPBlock.Ips.ApplyT(func(ips []string) (string, error) {
					return ips[2], nil
				}).(pulumi.StringOutput),
			},
			Lans: k8s.NodePoolLanArray{
				&k8s.NodePoolLanArgs{
					Id:   exampleLan.ID(),
					Dhcp: pulumi.Bool(true),
					Routes: k8s.NodePoolLanRouteArray{
						&k8s.NodePoolLanRouteArgs{
							Network:   pulumi.String("1.2.3.5/24"),
							GatewayIp: pulumi.String("10.1.5.17"),
						},
					},
				},
			},
			Labels: pulumi.StringMap{
				"lab1": pulumi.String("value1"),
				"lab2": pulumi.String("value2"),
			},
			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 = "us/las",
        Description = "datacenter description",
        SecAuthProtection = false,
    });

    var exampleLan = new Ionoscloud.Compute.Lan("example", new()
    {
        DatacenterId = example.Id,
        Public = false,
        Name = "Lan Example",
    });

    var exampleIPBlock = new Ionoscloud.Compute.IPBlock("example", new()
    {
        Location = "us/las",
        Size = 3,
        Name = "IP Block Example",
    });

    var exampleCluster = new Ionoscloud.K8s.Cluster("example", new()
    {
        Name = "k8sClusterExample",
        K8sVersion = "1.31.2",
        MaintenanceWindow = new Ionoscloud.K8s.Inputs.ClusterMaintenanceWindowArgs
        {
            DayOfTheWeek = "Sunday",
            Time = "09:00:00Z",
        },
        ApiSubnetAllowLists = new[]
        {
            "1.2.3.4/32",
        },
        S3Buckets = new[]
        {
            new Ionoscloud.K8s.Inputs.ClusterS3BucketArgs
            {
                Name = "globally_unique_s3_bucket_name",
            },
        },
    });

    var exampleNodePool = new Ionoscloud.K8s.NodePool("example", new()
    {
        DatacenterId = example.Id,
        K8sClusterId = exampleCluster.Id,
        Name = "k8sNodePoolExample",
        K8sVersion = exampleCluster.K8sVersion,
        MaintenanceWindow = new Ionoscloud.K8s.Inputs.NodePoolMaintenanceWindowArgs
        {
            DayOfTheWeek = "Monday",
            Time = "09:00:00Z",
        },
        AutoScaling = new Ionoscloud.K8s.Inputs.NodePoolAutoScalingArgs
        {
            MinNodeCount = 1,
            MaxNodeCount = 2,
        },
        CpuFamily = "INTEL_XEON",
        AvailabilityZone = "AUTO",
        StorageType = "SSD",
        NodeCount = 1,
        CoresCount = 2,
        RamSize = 2048,
        StorageSize = 40,
        PublicIps = new[]
        {
            exampleIPBlock.Ips.Apply(ips => ips[0]),
            exampleIPBlock.Ips.Apply(ips => ips[1]),
            exampleIPBlock.Ips.Apply(ips => ips[2]),
        },
        Lans = new[]
        {
            new Ionoscloud.K8s.Inputs.NodePoolLanArgs
            {
                Id = exampleLan.Id,
                Dhcp = true,
                Routes = new[]
                {
                    new Ionoscloud.K8s.Inputs.NodePoolLanRouteArgs
                    {
                        Network = "1.2.3.5/24",
                        GatewayIp = "10.1.5.17",
                    },
                },
            },
        },
        Labels = 
        {
            { "lab1", "value1" },
            { "lab2", "value2" },
        },
        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.compute.Lan;
import com.pulumi.ionoscloud.compute.LanArgs;
import com.pulumi.ionoscloud.compute.IPBlock;
import com.pulumi.ionoscloud.compute.IPBlockArgs;
import com.pulumi.ionoscloud.k8s.Cluster;
import com.pulumi.ionoscloud.k8s.ClusterArgs;
import com.pulumi.ionoscloud.k8s.inputs.ClusterMaintenanceWindowArgs;
import com.pulumi.ionoscloud.k8s.inputs.ClusterS3BucketArgs;
import com.pulumi.ionoscloud.k8s.NodePool;
import com.pulumi.ionoscloud.k8s.NodePoolArgs;
import com.pulumi.ionoscloud.k8s.inputs.NodePoolMaintenanceWindowArgs;
import com.pulumi.ionoscloud.k8s.inputs.NodePoolAutoScalingArgs;
import com.pulumi.ionoscloud.k8s.inputs.NodePoolLanArgs;
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("us/las")
            .description("datacenter description")
            .secAuthProtection(false)
            .build());

        var exampleLan = new Lan("exampleLan", LanArgs.builder()
            .datacenterId(example.id())
            .public_(false)
            .name("Lan Example")
            .build());

        var exampleIPBlock = new IPBlock("exampleIPBlock", IPBlockArgs.builder()
            .location("us/las")
            .size(3)
            .name("IP Block Example")
            .build());

        var exampleCluster = new Cluster("exampleCluster", ClusterArgs.builder()
            .name("k8sClusterExample")
            .k8sVersion("1.31.2")
            .maintenanceWindow(ClusterMaintenanceWindowArgs.builder()
                .dayOfTheWeek("Sunday")
                .time("09:00:00Z")
                .build())
            .apiSubnetAllowLists("1.2.3.4/32")
            .s3Buckets(ClusterS3BucketArgs.builder()
                .name("globally_unique_s3_bucket_name")
                .build())
            .build());

        var exampleNodePool = new NodePool("exampleNodePool", NodePoolArgs.builder()
            .datacenterId(example.id())
            .k8sClusterId(exampleCluster.id())
            .name("k8sNodePoolExample")
            .k8sVersion(exampleCluster.k8sVersion())
            .maintenanceWindow(NodePoolMaintenanceWindowArgs.builder()
                .dayOfTheWeek("Monday")
                .time("09:00:00Z")
                .build())
            .autoScaling(NodePoolAutoScalingArgs.builder()
                .minNodeCount(1)
                .maxNodeCount(2)
                .build())
            .cpuFamily("INTEL_XEON")
            .availabilityZone("AUTO")
            .storageType("SSD")
            .nodeCount(1)
            .coresCount(2)
            .ramSize(2048)
            .storageSize(40)
            .publicIps(            
                exampleIPBlock.ips().applyValue(ips -> ips[0]),
                exampleIPBlock.ips().applyValue(ips -> ips[1]),
                exampleIPBlock.ips().applyValue(ips -> ips[2]))
            .lans(NodePoolLanArgs.builder()
                .id(exampleLan.id())
                .dhcp(true)
                .routes(NodePoolLanRouteArgs.builder()
                    .network("1.2.3.5/24")
                    .gatewayIp("10.1.5.17")
                    .build())
                .build())
            .labels(Map.ofEntries(
                Map.entry("lab1", "value1"),
                Map.entry("lab2", "value2")
            ))
            .annotations(Map.ofEntries(
                Map.entry("ann1", "value1"),
                Map.entry("ann2", "value2")
            ))
            .build());

    }
}

resources:
  example:
    type: ionoscloud:compute:Datacenter
    properties:
      name: Datacenter Example
      location: us/las
      description: datacenter description
      secAuthProtection: false
  exampleLan:
    type: ionoscloud:compute:Lan
    name: example
    properties:
      datacenterId: ${example.id}
      public: false
      name: Lan Example
  exampleIPBlock:
    type: ionoscloud:compute:IPBlock
    name: example
    properties:
      location: us/las
      size: 3
      name: IP Block Example
  exampleCluster:
    type: ionoscloud:k8s:Cluster
    name: example
    properties:
      name: k8sClusterExample
      k8sVersion: 1.31.2
      maintenanceWindow:
        dayOfTheWeek: Sunday
        time: 09:00:00Z
      apiSubnetAllowLists:
        - 1.2.3.4/32
      s3Buckets:
        - name: globally_unique_s3_bucket_name
  exampleNodePool:
    type: ionoscloud:k8s:NodePool
    name: example
    properties:
      datacenterId: ${example.id}
      k8sClusterId: ${exampleCluster.id}
      name: k8sNodePoolExample
      k8sVersion: ${exampleCluster.k8sVersion}
      maintenanceWindow:
        dayOfTheWeek: Monday
        time: 09:00:00Z
      autoScaling:
        minNodeCount: 1
        maxNodeCount: 2
      cpuFamily: INTEL_XEON
      availabilityZone: AUTO
      storageType: SSD
      nodeCount: 1
      coresCount: 2
      ramSize: 2048
      storageSize: 40
      publicIps:
        - ${exampleIPBlock.ips[0]}
        - ${exampleIPBlock.ips[1]}
        - ${exampleIPBlock.ips[2]}
      lans:
        - id: ${exampleLan.id}
          dhcp: true
          routes:
            - network: 1.2.3.5/24
              gatewayIp: 10.1.5.17
      labels:
        lab1: value1
        lab2: value2
      annotations:
        ann1: value1
        ann2: value2

var ionoscloudNodePoolResource = new Ionoscloud.K8s.NodePool("ionoscloudNodePoolResource", new()
{
    K8sVersion = "string",
    NodeCount = 0,
    StorageType = "string",
    AvailabilityZone = "string",
    CoresCount = 0,
    CpuFamily = "string",
    DatacenterId = "string",
    K8sClusterId = "string",
    StorageSize = 0,
    RamSize = 0,
    Labels = 
    {
        { "string", "string" },
    },
    MaintenanceWindow = new Ionoscloud.K8s.Inputs.NodePoolMaintenanceWindowArgs
    {
        DayOfTheWeek = "string",
        Time = "string",
    },
    Name = "string",
    AllowReplace = false,
    PublicIps = new[]
    {
        "string",
    },
    Lans = new[]
    {
        new Ionoscloud.K8s.Inputs.NodePoolLanArgs
        {
            Id = 0,
            Dhcp = false,
            Routes = new[]
            {
                new Ionoscloud.K8s.Inputs.NodePoolLanRouteArgs
                {
                    GatewayIp = "string",
                    Network = "string",
                },
            },
        },
    },
    Annotations = 
    {
        { "string", "string" },
    },
    AutoScaling = new Ionoscloud.K8s.Inputs.NodePoolAutoScalingArgs
    {
        MaxNodeCount = 0,
        MinNodeCount = 0,
    },
});

example, err := k8s.NewNodePool(ctx, "ionoscloudNodePoolResource", &k8s.NodePoolArgs{
	K8sVersion:       pulumi.String("string"),
	NodeCount:        pulumi.Int(0),
	StorageType:      pulumi.String("string"),
	AvailabilityZone: pulumi.String("string"),
	CoresCount:       pulumi.Int(0),
	CpuFamily:        pulumi.String("string"),
	DatacenterId:     pulumi.String("string"),
	K8sClusterId:     pulumi.String("string"),
	StorageSize:      pulumi.Int(0),
	RamSize:          pulumi.Int(0),
	Labels: pulumi.StringMap{
		"string": pulumi.String("string"),
	},
	MaintenanceWindow: &k8s.NodePoolMaintenanceWindowArgs{
		DayOfTheWeek: pulumi.String("string"),
		Time:         pulumi.String("string"),
	},
	Name:         pulumi.String("string"),
	AllowReplace: pulumi.Bool(false),
	PublicIps: pulumi.StringArray{
		pulumi.String("string"),
	},
	Lans: k8s.NodePoolLanArray{
		&k8s.NodePoolLanArgs{
			Id:   pulumi.Int(0),
			Dhcp: pulumi.Bool(false),
			Routes: k8s.NodePoolLanRouteArray{
				&k8s.NodePoolLanRouteArgs{
					GatewayIp: pulumi.String("string"),
					Network:   pulumi.String("string"),
				},
			},
		},
	},
	Annotations: pulumi.StringMap{
		"string": pulumi.String("string"),
	},
	AutoScaling: &k8s.NodePoolAutoScalingArgs{
		MaxNodeCount: pulumi.Int(0),
		MinNodeCount: pulumi.Int(0),
	},
})

var ionoscloudNodePoolResource = new com.ionoscloud.pulumi.ionoscloud.k8s.NodePool("ionoscloudNodePoolResource", com.ionoscloud.pulumi.ionoscloud.k8s.NodePoolArgs.builder()
    .k8sVersion("string")
    .nodeCount(0)
    .storageType("string")
    .availabilityZone("string")
    .coresCount(0)
    .cpuFamily("string")
    .datacenterId("string")
    .k8sClusterId("string")
    .storageSize(0)
    .ramSize(0)
    .labels(Map.of("string", "string"))
    .maintenanceWindow(NodePoolMaintenanceWindowArgs.builder()
        .dayOfTheWeek("string")
        .time("string")
        .build())
    .name("string")
    .allowReplace(false)
    .publicIps("string")
    .lans(NodePoolLanArgs.builder()
        .id(0)
        .dhcp(false)
        .routes(NodePoolLanRouteArgs.builder()
            .gatewayIp("string")
            .network("string")
            .build())
        .build())
    .annotations(Map.of("string", "string"))
    .autoScaling(NodePoolAutoScalingArgs.builder()
        .maxNodeCount(0)
        .minNodeCount(0)
        .build())
    .build());

ionoscloud_node_pool_resource = ionoscloud.k8s.NodePool("ionoscloudNodePoolResource",
    k8s_version="string",
    node_count=0,
    storage_type="string",
    availability_zone="string",
    cores_count=0,
    cpu_family="string",
    datacenter_id="string",
    k8s_cluster_id="string",
    storage_size=0,
    ram_size=0,
    labels={
        "string": "string",
    },
    maintenance_window={
        "day_of_the_week": "string",
        "time": "string",
    },
    name="string",
    allow_replace=False,
    public_ips=["string"],
    lans=[{
        "id": 0,
        "dhcp": False,
        "routes": [{
            "gateway_ip": "string",
            "network": "string",
        }],
    }],
    annotations={
        "string": "string",
    },
    auto_scaling={
        "max_node_count": 0,
        "min_node_count": 0,
    })

const ionoscloudNodePoolResource = new ionoscloud.k8s.NodePool("ionoscloudNodePoolResource", {
    k8sVersion: "string",
    nodeCount: 0,
    storageType: "string",
    availabilityZone: "string",
    coresCount: 0,
    cpuFamily: "string",
    datacenterId: "string",
    k8sClusterId: "string",
    storageSize: 0,
    ramSize: 0,
    labels: {
        string: "string",
    },
    maintenanceWindow: {
        dayOfTheWeek: "string",
        time: "string",
    },
    name: "string",
    allowReplace: false,
    publicIps: ["string"],
    lans: [{
        id: 0,
        dhcp: false,
        routes: [{
            gatewayIp: "string",
            network: "string",
        }],
    }],
    annotations: {
        string: "string",
    },
    autoScaling: {
        maxNodeCount: 0,
        minNodeCount: 0,
    },
});

type: ionoscloud:k8s:NodePool
properties:
    allowReplace: false
    annotations:
        string: string
    autoScaling:
        maxNodeCount: 0
        minNodeCount: 0
    availabilityZone: string
    coresCount: 0
    cpuFamily: string
    datacenterId: string
    k8sClusterId: string
    k8sVersion: string
    labels:
        string: string
    lans:
        - dhcp: false
          id: 0
          routes:
            - gatewayIp: string
              network: string
    maintenanceWindow:
        dayOfTheWeek: string
        time: string
    name: string
    nodeCount: 0
    publicIps:
        - string
    ramSize: 0
    storageSize: 0
    storageType: string