Docs Home Pulumi IaC Pulumi ESC Pulumi Cloud Packages Tutorials
  1. Packages
  2. UpCloud
  3. API Docs
  4. KubernetesCluster
UpCloud v0.1.0 published on Friday, Mar 14, 2025 by UpCloudLtd
UpCloudLtd/pulumi-upcloud

upcloud.KubernetesCluster

Explore with Pulumi AI

upcloud logo
UpCloud v0.1.0 published on Friday, Mar 14, 2025 by UpCloudLtd
UpCloudLtd/pulumi-upcloud

    This resource represents a Managed Kubernetes cluster.

    Example Usage

    import * as pulumi from "@pulumi/pulumi";
import * as upcloud from "@upcloud/pulumi-upcloud";

// Create a network for the Kubernetes cluster
const example = new upcloud.Network("example", {
    name: "example-network",
    zone: "de-fra1",
    ipNetwork: {
        address: "172.16.1.0/24",
        dhcp: true,
        family: "IPv4",
    },
});
// Create a Kubernetes cluster
const exampleKubernetesCluster = new upcloud.KubernetesCluster("example", {
    controlPlaneIpFilters: ["0.0.0.0/0"],
    name: "exampleapp",
    network: example.id,
    zone: "de-fra1",
});
// Kubernetes cluster with private node groups requires a network that is routed through NAT gateway.
const example2 = new upcloud.Router("example2", {name: "example2-router"});
const example2Gateway = new upcloud.Gateway("example2", {
    name: "example2-nat-gateway",
    zone: "de-fra1",
    features: ["nat"],
    router: {
        id: example2.id,
    },
});
const example2Network = new upcloud.Network("example2", {
    name: "example2-network",
    zone: "de-fra1",
    ipNetwork: {
        address: "10.10.0.0/24",
        dhcp: true,
        family: "IPv4",
        dhcpDefaultRoute: true,
    },
    router: example2.id,
});
const example2KubernetesCluster = new upcloud.KubernetesCluster("example2", {
    name: "example2-cluster",
    network: example2Network.id,
    zone: "de-fra1",
    plan: "production-small",
    privateNodeGroups: true,
});

    import pulumi
import pulumi_upcloud as upcloud

# Create a network for the Kubernetes cluster
example = upcloud.Network("example",
    name="example-network",
    zone="de-fra1",
    ip_network={
        "address": "172.16.1.0/24",
        "dhcp": True,
        "family": "IPv4",
    })
# Create a Kubernetes cluster
example_kubernetes_cluster = upcloud.KubernetesCluster("example",
    control_plane_ip_filters=["0.0.0.0/0"],
    name="exampleapp",
    network=example.id,
    zone="de-fra1")
# Kubernetes cluster with private node groups requires a network that is routed through NAT gateway.
example2 = upcloud.Router("example2", name="example2-router")
example2_gateway = upcloud.Gateway("example2",
    name="example2-nat-gateway",
    zone="de-fra1",
    features=["nat"],
    router={
        "id": example2.id,
    })
example2_network = upcloud.Network("example2",
    name="example2-network",
    zone="de-fra1",
    ip_network={
        "address": "10.10.0.0/24",
        "dhcp": True,
        "family": "IPv4",
        "dhcp_default_route": True,
    },
    router=example2.id)
example2_kubernetes_cluster = upcloud.KubernetesCluster("example2",
    name="example2-cluster",
    network=example2_network.id,
    zone="de-fra1",
    plan="production-small",
    private_node_groups=True)

    package main

import (
	"github.com/UpCloudLtd/pulumi-upcloud/sdk/go/upcloud"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Create a network for the Kubernetes cluster
		example, err := upcloud.NewNetwork(ctx, "example", &upcloud.NetworkArgs{
			Name: pulumi.String("example-network"),
			Zone: pulumi.String("de-fra1"),
			IpNetwork: &upcloud.NetworkIpNetworkArgs{
				Address: pulumi.String("172.16.1.0/24"),
				Dhcp:    pulumi.Bool(true),
				Family:  pulumi.String("IPv4"),
			},
		})
		if err != nil {
			return err
		}
		// Create a Kubernetes cluster
		_, err = upcloud.NewKubernetesCluster(ctx, "example", &upcloud.KubernetesClusterArgs{
			ControlPlaneIpFilters: pulumi.StringArray{
				pulumi.String("0.0.0.0/0"),
			},
			Name:    pulumi.String("exampleapp"),
			Network: example.ID(),
			Zone:    pulumi.String("de-fra1"),
		})
		if err != nil {
			return err
		}
		// Kubernetes cluster with private node groups requires a network that is routed through NAT gateway.
		example2, err := upcloud.NewRouter(ctx, "example2", &upcloud.RouterArgs{
			Name: pulumi.String("example2-router"),
		})
		if err != nil {
			return err
		}
		_, err = upcloud.NewGateway(ctx, "example2", &upcloud.GatewayArgs{
			Name: pulumi.String("example2-nat-gateway"),
			Zone: pulumi.String("de-fra1"),
			Features: pulumi.StringArray{
				pulumi.String("nat"),
			},
			Router: &upcloud.GatewayRouterArgs{
				Id: example2.ID(),
			},
		})
		if err != nil {
			return err
		}
		example2Network, err := upcloud.NewNetwork(ctx, "example2", &upcloud.NetworkArgs{
			Name: pulumi.String("example2-network"),
			Zone: pulumi.String("de-fra1"),
			IpNetwork: &upcloud.NetworkIpNetworkArgs{
				Address:          pulumi.String("10.10.0.0/24"),
				Dhcp:             pulumi.Bool(true),
				Family:           pulumi.String("IPv4"),
				DhcpDefaultRoute: pulumi.Bool(true),
			},
			Router: example2.ID(),
		})
		if err != nil {
			return err
		}
		_, err = upcloud.NewKubernetesCluster(ctx, "example2", &upcloud.KubernetesClusterArgs{
			Name:              pulumi.String("example2-cluster"),
			Network:           example2Network.ID(),
			Zone:              pulumi.String("de-fra1"),
			Plan:              pulumi.String("production-small"),
			PrivateNodeGroups: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    // Create a network for the Kubernetes cluster
    var example = new UpCloud.Network("example", new()
    {
        Name = "example-network",
        Zone = "de-fra1",
        IpNetwork = new UpCloud.Inputs.NetworkIpNetworkArgs
        {
            Address = "172.16.1.0/24",
            Dhcp = true,
            Family = "IPv4",
        },
    });

    // Create a Kubernetes cluster
    var exampleKubernetesCluster = new UpCloud.KubernetesCluster("example", new()
    {
        ControlPlaneIpFilters = new[]
        {
            "0.0.0.0/0",
        },
        Name = "exampleapp",
        Network = example.Id,
        Zone = "de-fra1",
    });

    // Kubernetes cluster with private node groups requires a network that is routed through NAT gateway.
    var example2 = new UpCloud.Router("example2", new()
    {
        Name = "example2-router",
    });

    var example2Gateway = new UpCloud.Gateway("example2", new()
    {
        Name = "example2-nat-gateway",
        Zone = "de-fra1",
        Features = new[]
        {
            "nat",
        },
        Router = new UpCloud.Inputs.GatewayRouterArgs
        {
            Id = example2.Id,
        },
    });

    var example2Network = new UpCloud.Network("example2", new()
    {
        Name = "example2-network",
        Zone = "de-fra1",
        IpNetwork = new UpCloud.Inputs.NetworkIpNetworkArgs
        {
            Address = "10.10.0.0/24",
            Dhcp = true,
            Family = "IPv4",
            DhcpDefaultRoute = true,
        },
        Router = example2.Id,
    });

    var example2KubernetesCluster = new UpCloud.KubernetesCluster("example2", new()
    {
        Name = "example2-cluster",
        Network = example2Network.Id,
        Zone = "de-fra1",
        Plan = "production-small",
        PrivateNodeGroups = true,
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.upcloud.Network;
import com.pulumi.upcloud.NetworkArgs;
import com.pulumi.upcloud.inputs.NetworkIpNetworkArgs;
import com.pulumi.upcloud.KubernetesCluster;
import com.pulumi.upcloud.KubernetesClusterArgs;
import com.pulumi.upcloud.Router;
import com.pulumi.upcloud.RouterArgs;
import com.pulumi.upcloud.Gateway;
import com.pulumi.upcloud.GatewayArgs;
import com.pulumi.upcloud.inputs.GatewayRouterArgs;
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) {
        // Create a network for the Kubernetes cluster
        var example = new Network("example", NetworkArgs.builder()
            .name("example-network")
            .zone("de-fra1")
            .ipNetwork(NetworkIpNetworkArgs.builder()
                .address("172.16.1.0/24")
                .dhcp(true)
                .family("IPv4")
                .build())
            .build());

        // Create a Kubernetes cluster
        var exampleKubernetesCluster = new KubernetesCluster("exampleKubernetesCluster", KubernetesClusterArgs.builder()
            .controlPlaneIpFilters("0.0.0.0/0")
            .name("exampleapp")
            .network(example.id())
            .zone("de-fra1")
            .build());

        // Kubernetes cluster with private node groups requires a network that is routed through NAT gateway.
        var example2 = new Router("example2", RouterArgs.builder()
            .name("example2-router")
            .build());

        var example2Gateway = new Gateway("example2Gateway", GatewayArgs.builder()
            .name("example2-nat-gateway")
            .zone("de-fra1")
            .features("nat")
            .router(GatewayRouterArgs.builder()
                .id(example2.id())
                .build())
            .build());

        var example2Network = new Network("example2Network", NetworkArgs.builder()
            .name("example2-network")
            .zone("de-fra1")
            .ipNetwork(NetworkIpNetworkArgs.builder()
                .address("10.10.0.0/24")
                .dhcp(true)
                .family("IPv4")
                .dhcpDefaultRoute(true)
                .build())
            .router(example2.id())
            .build());

        var example2KubernetesCluster = new KubernetesCluster("example2KubernetesCluster", KubernetesClusterArgs.builder()
            .name("example2-cluster")
            .network(example2Network.id())
            .zone("de-fra1")
            .plan("production-small")
            .privateNodeGroups(true)
            .build());

    }
}

    resources:
  # Create a network for the Kubernetes cluster
  example:
    type: upcloud:Network
    properties:
      name: example-network
      zone: de-fra1
      ipNetwork:
        address: 172.16.1.0/24
        dhcp: true
        family: IPv4
  # Create a Kubernetes cluster
  exampleKubernetesCluster:
    type: upcloud:KubernetesCluster
    name: example
    properties:
      controlPlaneIpFilters:
        - 0.0.0.0/0
      name: exampleapp
      network: ${example.id}
      zone: de-fra1
  # Kubernetes cluster with private node groups requires a network that is routed through NAT gateway.
  example2:
    type: upcloud:Router
    properties:
      name: example2-router
  example2Gateway:
    type: upcloud:Gateway
    name: example2
    properties:
      name: example2-nat-gateway
      zone: de-fra1
      features:
        - nat
      router:
        id: ${example2.id}
  example2Network:
    type: upcloud:Network
    name: example2
    properties:
      name: example2-network
      zone: de-fra1
      ipNetwork:
        address: 10.10.0.0/24
        dhcp: true
        family: IPv4
        dhcpDefaultRoute: true
      router: ${example2.id}
  example2KubernetesCluster:
    type: upcloud:KubernetesCluster
    name: example2
    properties:
      name: example2-cluster
      network: ${example2Network.id}
      zone: de-fra1
      plan: production-small
      privateNodeGroups: true

    Create KubernetesCluster Resource

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

    Constructor syntax

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

@overload
def KubernetesCluster(resource_name: str,
                      opts: Optional[ResourceOptions] = None,
                      control_plane_ip_filters: Optional[Sequence[str]] = None,
                      network: Optional[str] = None,
                      zone: Optional[str] = None,
                      labels: Optional[Mapping[str, str]] = None,
                      name: Optional[str] = None,
                      plan: Optional[str] = None,
                      private_node_groups: Optional[bool] = None,
                      storage_encryption: Optional[str] = None,
                      version: Optional[str] = None)
    func NewKubernetesCluster(ctx *Context, name string, args KubernetesClusterArgs, opts ...ResourceOption) (*KubernetesCluster, error)
    public KubernetesCluster(string name, KubernetesClusterArgs args, CustomResourceOptions? opts = null)
    public KubernetesCluster(String name, KubernetesClusterArgs args)
public KubernetesCluster(String name, KubernetesClusterArgs args, CustomResourceOptions options)

    type: upcloud:KubernetesCluster
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 KubernetesClusterArgs
    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 KubernetesClusterArgs
    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 KubernetesClusterArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args KubernetesClusterArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args KubernetesClusterArgs
    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 kubernetesClusterResource = new UpCloud.KubernetesCluster("kubernetesClusterResource", new()
{
    ControlPlaneIpFilters = new[]
    {
        "string",
    },
    Network = "string",
    Zone = "string",
    Labels = 
    {
        { "string", "string" },
    },
    Name = "string",
    Plan = "string",
    PrivateNodeGroups = false,
    StorageEncryption = "string",
    Version = "string",
});

    example, err := upcloud.NewKubernetesCluster(ctx, "kubernetesClusterResource", &upcloud.KubernetesClusterArgs{
	ControlPlaneIpFilters: pulumi.StringArray{
		pulumi.String("string"),
	},
	Network: pulumi.String("string"),
	Zone:    pulumi.String("string"),
	Labels: pulumi.StringMap{
		"string": pulumi.String("string"),
	},
	Name:              pulumi.String("string"),
	Plan:              pulumi.String("string"),
	PrivateNodeGroups: pulumi.Bool(false),
	StorageEncryption: pulumi.String("string"),
	Version:           pulumi.String("string"),
})

    var kubernetesClusterResource = new KubernetesCluster("kubernetesClusterResource", KubernetesClusterArgs.builder()
    .controlPlaneIpFilters("string")
    .network("string")
    .zone("string")
    .labels(Map.of("string", "string"))
    .name("string")
    .plan("string")
    .privateNodeGroups(false)
    .storageEncryption("string")
    .version("string")
    .build());

    kubernetes_cluster_resource = upcloud.KubernetesCluster("kubernetesClusterResource",
    control_plane_ip_filters=["string"],
    network="string",
    zone="string",
    labels={
        "string": "string",
    },
    name="string",
    plan="string",
    private_node_groups=False,
    storage_encryption="string",
    version="string")

    const kubernetesClusterResource = new upcloud.KubernetesCluster("kubernetesClusterResource", {
    controlPlaneIpFilters: ["string"],
    network: "string",
    zone: "string",
    labels: {
        string: "string",
    },
    name: "string",
    plan: "string",
    privateNodeGroups: false,
    storageEncryption: "string",
    version: "string",
});

    type: upcloud:KubernetesCluster
properties:
    controlPlaneIpFilters:
        - string
    labels:
        string: string
    name: string
    network: string
    plan: string
    privateNodeGroups: false
    storageEncryption: string
    version: string
    zone: string

    KubernetesCluster 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 KubernetesCluster resource accepts the following input properties:

    ControlPlaneIpFilters List<string>
    IP addresses or IP ranges in CIDR format which are allowed to access the cluster control plane. To allow access from any source, use ["0.0.0.0/0"]. To deny access from all sources, use []. Values set here do not restrict access to node groups or exposed Kubernetes services.
    Network string
    Network ID for the cluster to run in.
    Zone string
    Zone in which the Kubernetes cluster will be hosted, e.g. de-fra1. You can list available zones with upctl zone list.
    Labels Dictionary<string, string>
    User defined key-value pairs to classify the cluster.
    Name string
    Cluster name. Needs to be unique within the account.
    Plan string
    The pricing plan used for the cluster. You can list available plans with upctl kubernetes plans.
    PrivateNodeGroups bool
    Enable private node groups. Private node groups requires a network that is routed through NAT gateway.
    StorageEncryption string
    Set default storage encryption strategy for all nodes in the cluster.
    Version string
    Kubernetes version ID, e.g. 1.30. You can list available version IDs with upctl kubernetes versions.
    ControlPlaneIpFilters []string
    IP addresses or IP ranges in CIDR format which are allowed to access the cluster control plane. To allow access from any source, use ["0.0.0.0/0"]. To deny access from all sources, use []. Values set here do not restrict access to node groups or exposed Kubernetes services.
    Network string
    Network ID for the cluster to run in.
    Zone string
    Zone in which the Kubernetes cluster will be hosted, e.g. de-fra1. You can list available zones with upctl zone list.
    Labels map[string]string
    User defined key-value pairs to classify the cluster.
    Name string
    Cluster name. Needs to be unique within the account.
    Plan string
    The pricing plan used for the cluster. You can list available plans with upctl kubernetes plans.
    PrivateNodeGroups bool
    Enable private node groups. Private node groups requires a network that is routed through NAT gateway.
    StorageEncryption string
    Set default storage encryption strategy for all nodes in the cluster.
    Version string
    Kubernetes version ID, e.g. 1.30. You can list available version IDs with upctl kubernetes versions.
    controlPlaneIpFilters List<String>
    IP addresses or IP ranges in CIDR format which are allowed to access the cluster control plane. To allow access from any source, use ["0.0.0.0/0"]. To deny access from all sources, use []. Values set here do not restrict access to node groups or exposed Kubernetes services.
    network String
    Network ID for the cluster to run in.
    zone String
    Zone in which the Kubernetes cluster will be hosted, e.g. de-fra1. You can list available zones with upctl zone list.
    labels Map<String,String>
    User defined key-value pairs to classify the cluster.
    name String
    Cluster name. Needs to be unique within the account.
    plan String
    The pricing plan used for the cluster. You can list available plans with upctl kubernetes plans.
    privateNodeGroups Boolean
    Enable private node groups. Private node groups requires a network that is routed through NAT gateway.
    storageEncryption String
    Set default storage encryption strategy for all nodes in the cluster.
    version String
    Kubernetes version ID, e.g. 1.30. You can list available version IDs with upctl kubernetes versions.
    controlPlaneIpFilters string[]
    IP addresses or IP ranges in CIDR format which are allowed to access the cluster control plane. To allow access from any source, use ["0.0.0.0/0"]. To deny access from all sources, use []. Values set here do not restrict access to node groups or exposed Kubernetes services.
    network string
    Network ID for the cluster to run in.
    zone string
    Zone in which the Kubernetes cluster will be hosted, e.g. de-fra1. You can list available zones with upctl zone list.
    labels {[key: string]: string}
    User defined key-value pairs to classify the cluster.
    name string
    Cluster name. Needs to be unique within the account.
    plan string
    The pricing plan used for the cluster. You can list available plans with upctl kubernetes plans.
    privateNodeGroups boolean
    Enable private node groups. Private node groups requires a network that is routed through NAT gateway.
    storageEncryption string
    Set default storage encryption strategy for all nodes in the cluster.
    version string
    Kubernetes version ID, e.g. 1.30. You can list available version IDs with upctl kubernetes versions.
    control_plane_ip_filters Sequence[str]
    IP addresses or IP ranges in CIDR format which are allowed to access the cluster control plane. To allow access from any source, use ["0.0.0.0/0"]. To deny access from all sources, use []. Values set here do not restrict access to node groups or exposed Kubernetes services.
    network str
    Network ID for the cluster to run in.
    zone str
    Zone in which the Kubernetes cluster will be hosted, e.g. de-fra1. You can list available zones with upctl zone list.
    labels Mapping[str, str]
    User defined key-value pairs to classify the cluster.
    name str
    Cluster name. Needs to be unique within the account.
    plan str
    The pricing plan used for the cluster. You can list available plans with upctl kubernetes plans.
    private_node_groups bool
    Enable private node groups. Private node groups requires a network that is routed through NAT gateway.
    storage_encryption str
    Set default storage encryption strategy for all nodes in the cluster.
    version str
    Kubernetes version ID, e.g. 1.30. You can list available version IDs with upctl kubernetes versions.
    controlPlaneIpFilters List<String>
    IP addresses or IP ranges in CIDR format which are allowed to access the cluster control plane. To allow access from any source, use ["0.0.0.0/0"]. To deny access from all sources, use []. Values set here do not restrict access to node groups or exposed Kubernetes services.
    network String
    Network ID for the cluster to run in.
    zone String
    Zone in which the Kubernetes cluster will be hosted, e.g. de-fra1. You can list available zones with upctl zone list.
    labels Map<String>
    User defined key-value pairs to classify the cluster.
    name String
    Cluster name. Needs to be unique within the account.
    plan String
    The pricing plan used for the cluster. You can list available plans with upctl kubernetes plans.
    privateNodeGroups Boolean
    Enable private node groups. Private node groups requires a network that is routed through NAT gateway.
    storageEncryption String
    Set default storage encryption strategy for all nodes in the cluster.
    version String
    Kubernetes version ID, e.g. 1.30. You can list available version IDs with upctl kubernetes versions.

    Outputs

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

    Id string
    The provider-assigned unique ID for this managed resource.
    NetworkCidr string
    Network CIDR for the given network. Computed automatically.
    NodeGroups List<string>
    Names of the node groups configured to cluster
    State string
    Operational state of the cluster.
    Id string
    The provider-assigned unique ID for this managed resource.
    NetworkCidr string
    Network CIDR for the given network. Computed automatically.
    NodeGroups []string
    Names of the node groups configured to cluster
    State string
    Operational state of the cluster.
    id String
    The provider-assigned unique ID for this managed resource.
    networkCidr String
    Network CIDR for the given network. Computed automatically.
    nodeGroups List<String>
    Names of the node groups configured to cluster
    state String
    Operational state of the cluster.
    id string
    The provider-assigned unique ID for this managed resource.
    networkCidr string
    Network CIDR for the given network. Computed automatically.
    nodeGroups string[]
    Names of the node groups configured to cluster
    state string
    Operational state of the cluster.
    id str
    The provider-assigned unique ID for this managed resource.
    network_cidr str
    Network CIDR for the given network. Computed automatically.
    node_groups Sequence[str]
    Names of the node groups configured to cluster
    state str
    Operational state of the cluster.
    id String
    The provider-assigned unique ID for this managed resource.
    networkCidr String
    Network CIDR for the given network. Computed automatically.
    nodeGroups List<String>
    Names of the node groups configured to cluster
    state String
    Operational state of the cluster.

    Look up Existing KubernetesCluster Resource

    Get an existing KubernetesCluster 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?: KubernetesClusterState, opts?: CustomResourceOptions): KubernetesCluster
    @staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        control_plane_ip_filters: Optional[Sequence[str]] = None,
        labels: Optional[Mapping[str, str]] = None,
        name: Optional[str] = None,
        network: Optional[str] = None,
        network_cidr: Optional[str] = None,
        node_groups: Optional[Sequence[str]] = None,
        plan: Optional[str] = None,
        private_node_groups: Optional[bool] = None,
        state: Optional[str] = None,
        storage_encryption: Optional[str] = None,
        version: Optional[str] = None,
        zone: Optional[str] = None) -> KubernetesCluster
    func GetKubernetesCluster(ctx *Context, name string, id IDInput, state *KubernetesClusterState, opts ...ResourceOption) (*KubernetesCluster, error)
    public static KubernetesCluster Get(string name, Input<string> id, KubernetesClusterState? state, CustomResourceOptions? opts = null)
    public static KubernetesCluster get(String name, Output<String> id, KubernetesClusterState state, CustomResourceOptions options)
    resources:  _:    type: upcloud:KubernetesCluster    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:
    ControlPlaneIpFilters List<string>
    IP addresses or IP ranges in CIDR format which are allowed to access the cluster control plane. To allow access from any source, use ["0.0.0.0/0"]. To deny access from all sources, use []. Values set here do not restrict access to node groups or exposed Kubernetes services.
    Labels Dictionary<string, string>
    User defined key-value pairs to classify the cluster.
    Name string
    Cluster name. Needs to be unique within the account.
    Network string
    Network ID for the cluster to run in.
    NetworkCidr string
    Network CIDR for the given network. Computed automatically.
    NodeGroups List<string>
    Names of the node groups configured to cluster
    Plan string
    The pricing plan used for the cluster. You can list available plans with upctl kubernetes plans.
    PrivateNodeGroups bool
    Enable private node groups. Private node groups requires a network that is routed through NAT gateway.
    State string
    Operational state of the cluster.
    StorageEncryption string
    Set default storage encryption strategy for all nodes in the cluster.
    Version string
    Kubernetes version ID, e.g. 1.30. You can list available version IDs with upctl kubernetes versions.
    Zone string
    Zone in which the Kubernetes cluster will be hosted, e.g. de-fra1. You can list available zones with upctl zone list.
    ControlPlaneIpFilters []string
    IP addresses or IP ranges in CIDR format which are allowed to access the cluster control plane. To allow access from any source, use ["0.0.0.0/0"]. To deny access from all sources, use []. Values set here do not restrict access to node groups or exposed Kubernetes services.
    Labels map[string]string
    User defined key-value pairs to classify the cluster.
    Name string
    Cluster name. Needs to be unique within the account.
    Network string
    Network ID for the cluster to run in.
    NetworkCidr string
    Network CIDR for the given network. Computed automatically.
    NodeGroups []string
    Names of the node groups configured to cluster
    Plan string
    The pricing plan used for the cluster. You can list available plans with upctl kubernetes plans.
    PrivateNodeGroups bool
    Enable private node groups. Private node groups requires a network that is routed through NAT gateway.
    State string
    Operational state of the cluster.
    StorageEncryption string
    Set default storage encryption strategy for all nodes in the cluster.
    Version string
    Kubernetes version ID, e.g. 1.30. You can list available version IDs with upctl kubernetes versions.
    Zone string
    Zone in which the Kubernetes cluster will be hosted, e.g. de-fra1. You can list available zones with upctl zone list.
    controlPlaneIpFilters List<String>
    IP addresses or IP ranges in CIDR format which are allowed to access the cluster control plane. To allow access from any source, use ["0.0.0.0/0"]. To deny access from all sources, use []. Values set here do not restrict access to node groups or exposed Kubernetes services.
    labels Map<String,String>
    User defined key-value pairs to classify the cluster.
    name String
    Cluster name. Needs to be unique within the account.
    network String
    Network ID for the cluster to run in.
    networkCidr String
    Network CIDR for the given network. Computed automatically.
    nodeGroups List<String>
    Names of the node groups configured to cluster
    plan String
    The pricing plan used for the cluster. You can list available plans with upctl kubernetes plans.
    privateNodeGroups Boolean
    Enable private node groups. Private node groups requires a network that is routed through NAT gateway.
    state String
    Operational state of the cluster.
    storageEncryption String
    Set default storage encryption strategy for all nodes in the cluster.
    version String
    Kubernetes version ID, e.g. 1.30. You can list available version IDs with upctl kubernetes versions.
    zone String
    Zone in which the Kubernetes cluster will be hosted, e.g. de-fra1. You can list available zones with upctl zone list.
    controlPlaneIpFilters string[]
    IP addresses or IP ranges in CIDR format which are allowed to access the cluster control plane. To allow access from any source, use ["0.0.0.0/0"]. To deny access from all sources, use []. Values set here do not restrict access to node groups or exposed Kubernetes services.
    labels {[key: string]: string}
    User defined key-value pairs to classify the cluster.
    name string
    Cluster name. Needs to be unique within the account.
    network string
    Network ID for the cluster to run in.
    networkCidr string
    Network CIDR for the given network. Computed automatically.
    nodeGroups string[]
    Names of the node groups configured to cluster
    plan string
    The pricing plan used for the cluster. You can list available plans with upctl kubernetes plans.
    privateNodeGroups boolean
    Enable private node groups. Private node groups requires a network that is routed through NAT gateway.
    state string
    Operational state of the cluster.
    storageEncryption string
    Set default storage encryption strategy for all nodes in the cluster.
    version string
    Kubernetes version ID, e.g. 1.30. You can list available version IDs with upctl kubernetes versions.
    zone string
    Zone in which the Kubernetes cluster will be hosted, e.g. de-fra1. You can list available zones with upctl zone list.
    control_plane_ip_filters Sequence[str]
    IP addresses or IP ranges in CIDR format which are allowed to access the cluster control plane. To allow access from any source, use ["0.0.0.0/0"]. To deny access from all sources, use []. Values set here do not restrict access to node groups or exposed Kubernetes services.
    labels Mapping[str, str]
    User defined key-value pairs to classify the cluster.
    name str
    Cluster name. Needs to be unique within the account.
    network str
    Network ID for the cluster to run in.
    network_cidr str
    Network CIDR for the given network. Computed automatically.
    node_groups Sequence[str]
    Names of the node groups configured to cluster
    plan str
    The pricing plan used for the cluster. You can list available plans with upctl kubernetes plans.
    private_node_groups bool
    Enable private node groups. Private node groups requires a network that is routed through NAT gateway.
    state str
    Operational state of the cluster.
    storage_encryption str
    Set default storage encryption strategy for all nodes in the cluster.
    version str
    Kubernetes version ID, e.g. 1.30. You can list available version IDs with upctl kubernetes versions.
    zone str
    Zone in which the Kubernetes cluster will be hosted, e.g. de-fra1. You can list available zones with upctl zone list.
    controlPlaneIpFilters List<String>
    IP addresses or IP ranges in CIDR format which are allowed to access the cluster control plane. To allow access from any source, use ["0.0.0.0/0"]. To deny access from all sources, use []. Values set here do not restrict access to node groups or exposed Kubernetes services.
    labels Map<String>
    User defined key-value pairs to classify the cluster.
    name String
    Cluster name. Needs to be unique within the account.
    network String
    Network ID for the cluster to run in.
    networkCidr String
    Network CIDR for the given network. Computed automatically.
    nodeGroups List<String>
    Names of the node groups configured to cluster
    plan String
    The pricing plan used for the cluster. You can list available plans with upctl kubernetes plans.
    privateNodeGroups Boolean
    Enable private node groups. Private node groups requires a network that is routed through NAT gateway.
    state String
    Operational state of the cluster.
    storageEncryption String
    Set default storage encryption strategy for all nodes in the cluster.
    version String
    Kubernetes version ID, e.g. 1.30. You can list available version IDs with upctl kubernetes versions.
    zone String
    Zone in which the Kubernetes cluster will be hosted, e.g. de-fra1. You can list available zones with upctl zone list.

    Package Details

    Repository
    upcloud UpCloudLtd/pulumi-upcloud
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the upcloud Terraform Provider.
    upcloud logo
    UpCloud v0.1.0 published on Friday, Mar 14, 2025 by UpCloudLtd
    UpCloudLtd/pulumi-upcloud