1. Packages
  2. Linode Provider
  3. API Docs
  4. LkeNodePool
Viewing docs for Linode v5.10.0
published on Wednesday, Apr 1, 2026 by Pulumi
Schema (JSON)
pulumi/pulumi-linode

linode.LkeNodePool

linode logo
Viewing docs for Linode v5.10.0
published on Wednesday, Apr 1, 2026 by Pulumi
Schema (JSON)
pulumi/pulumi-linode

    Manages an LKE Node Pool. For more information, see the Linode APIv4 docs.

    Notice To prevent LKE node pools managed by this resource from being recreated by the linode.LkeCluster resource, the cluster’s externalPoolTags attribute must match the tags attribute of this resource. Please review the Externally Managed Node Pools section for more information.

    Example Usage

    import * as pulumi from "@pulumi/pulumi";
import * as linode from "@pulumi/linode";

const my_pool = new linode.LkeNodePool("my-pool", {
    clusterId: 150003,
    type: "g6-standard-2",
    nodeCount: 3,
});

    import pulumi
import pulumi_linode as linode

my_pool = linode.LkeNodePool("my-pool",
    cluster_id=150003,
    type="g6-standard-2",
    node_count=3)

    package main

import (
	"github.com/pulumi/pulumi-linode/sdk/v5/go/linode"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := linode.NewLkeNodePool(ctx, "my-pool", &linode.LkeNodePoolArgs{
			ClusterId: pulumi.Int(150003),
			Type:      pulumi.String("g6-standard-2"),
			NodeCount: pulumi.Int(3),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var my_pool = new Linode.LkeNodePool("my-pool", new()
    {
        ClusterId = 150003,
        Type = "g6-standard-2",
        NodeCount = 3,
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.linode.LkeNodePool;
import com.pulumi.linode.LkeNodePoolArgs;
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 my_pool = new LkeNodePool("my-pool", LkeNodePoolArgs.builder()
            .clusterId(150003)
            .type("g6-standard-2")
            .nodeCount(3)
            .build());

    }
}

    resources:
  my-pool:
    type: linode:LkeNodePool
    properties:
      clusterId: 150003
      type: g6-standard-2
      nodeCount: 3

    import * as pulumi from "@pulumi/pulumi";
import * as linode from "@pulumi/linode";

const my_pool = new linode.LkeNodePool("my-pool", {
    clusterId: 150003,
    type: "g6-standard-2",
    nodeCount: 3,
    label: "app-pool",
});

    import pulumi
import pulumi_linode as linode

my_pool = linode.LkeNodePool("my-pool",
    cluster_id=150003,
    type="g6-standard-2",
    node_count=3,
    label="app-pool")

    package main

import (
	"github.com/pulumi/pulumi-linode/sdk/v5/go/linode"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := linode.NewLkeNodePool(ctx, "my-pool", &linode.LkeNodePoolArgs{
			ClusterId: pulumi.Int(150003),
			Type:      pulumi.String("g6-standard-2"),
			NodeCount: pulumi.Int(3),
			Label:     pulumi.String("app-pool"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var my_pool = new Linode.LkeNodePool("my-pool", new()
    {
        ClusterId = 150003,
        Type = "g6-standard-2",
        NodeCount = 3,
        Label = "app-pool",
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.linode.LkeNodePool;
import com.pulumi.linode.LkeNodePoolArgs;
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 my_pool = new LkeNodePool("my-pool", LkeNodePoolArgs.builder()
            .clusterId(150003)
            .type("g6-standard-2")
            .nodeCount(3)
            .label("app-pool")
            .build());

    }
}

    resources:
  my-pool:
    type: linode:LkeNodePool
    properties:
      clusterId: 150003
      type: g6-standard-2
      nodeCount: 3
      label: app-pool

    import * as pulumi from "@pulumi/pulumi";
import * as linode from "@pulumi/linode";

const my_pool = new linode.LkeNodePool("my-pool", {
    clusterId: 150003,
    type: "g6-standard-2",
    firewallId: 12345,
    nodeCount: 3,
});

    import pulumi
import pulumi_linode as linode

my_pool = linode.LkeNodePool("my-pool",
    cluster_id=150003,
    type="g6-standard-2",
    firewall_id=12345,
    node_count=3)

    package main

import (
	"github.com/pulumi/pulumi-linode/sdk/v5/go/linode"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := linode.NewLkeNodePool(ctx, "my-pool", &linode.LkeNodePoolArgs{
			ClusterId:  pulumi.Int(150003),
			Type:       pulumi.String("g6-standard-2"),
			FirewallId: pulumi.Int(12345),
			NodeCount:  pulumi.Int(3),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var my_pool = new Linode.LkeNodePool("my-pool", new()
    {
        ClusterId = 150003,
        Type = "g6-standard-2",
        FirewallId = 12345,
        NodeCount = 3,
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.linode.LkeNodePool;
import com.pulumi.linode.LkeNodePoolArgs;
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 my_pool = new LkeNodePool("my-pool", LkeNodePoolArgs.builder()
            .clusterId(150003)
            .type("g6-standard-2")
            .firewallId(12345)
            .nodeCount(3)
            .build());

    }
}

    resources:
  my-pool:
    type: linode:LkeNodePool
    properties:
      clusterId: 150003
      type: g6-standard-2
      firewallId: 12345
      nodeCount: 3

    import * as pulumi from "@pulumi/pulumi";
import * as linode from "@pulumi/linode";

const my_pool = new linode.LkeNodePool("my-pool", {
    clusterId: 150003,
    type: "g6-standard-2",
    autoscaler: {
        min: 3,
        max: 10,
    },
});

    import pulumi
import pulumi_linode as linode

my_pool = linode.LkeNodePool("my-pool",
    cluster_id=150003,
    type="g6-standard-2",
    autoscaler={
        "min": 3,
        "max": 10,
    })

    package main

import (
	"github.com/pulumi/pulumi-linode/sdk/v5/go/linode"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := linode.NewLkeNodePool(ctx, "my-pool", &linode.LkeNodePoolArgs{
			ClusterId: pulumi.Int(150003),
			Type:      pulumi.String("g6-standard-2"),
			Autoscaler: &linode.LkeNodePoolAutoscalerArgs{
				Min: pulumi.Int(3),
				Max: pulumi.Int(10),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var my_pool = new Linode.LkeNodePool("my-pool", new()
    {
        ClusterId = 150003,
        Type = "g6-standard-2",
        Autoscaler = new Linode.Inputs.LkeNodePoolAutoscalerArgs
        {
            Min = 3,
            Max = 10,
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.linode.LkeNodePool;
import com.pulumi.linode.LkeNodePoolArgs;
import com.pulumi.linode.inputs.LkeNodePoolAutoscalerArgs;
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 my_pool = new LkeNodePool("my-pool", LkeNodePoolArgs.builder()
            .clusterId(150003)
            .type("g6-standard-2")
            .autoscaler(LkeNodePoolAutoscalerArgs.builder()
                .min(3)
                .max(10)
                .build())
            .build());

    }
}

    resources:
  my-pool:
    type: linode:LkeNodePool
    properties:
      clusterId: 150003
      type: g6-standard-2
      autoscaler:
        min: 3
        max: 10

    import * as pulumi from "@pulumi/pulumi";
import * as linode from "@pulumi/linode";

const externalPoolTag = "external";
const my_cluster = new linode.LkeCluster("my-cluster", {
    label: "my-cluster",
    k8sVersion: "1.32",
    region: "us-mia",
    labels: {
        key: "value",
    },
    externalPoolTags: [externalPoolTag],
    pools: [{
        type: "g6-standard-1",
        count: 1,
    }],
});
const my_pool = new linode.LkeNodePool("my-pool", {
    clusterId: my_cluster.id,
    type: "g6-standard-2",
    nodeCount: 3,
    tags: [externalPoolTag],
});

    import pulumi
import pulumi_linode as linode

external_pool_tag = "external"
my_cluster = linode.LkeCluster("my-cluster",
    label="my-cluster",
    k8s_version="1.32",
    region="us-mia",
    labels={
        "key": "value",
    },
    external_pool_tags=[external_pool_tag],
    pools=[{
        "type": "g6-standard-1",
        "count": 1,
    }])
my_pool = linode.LkeNodePool("my-pool",
    cluster_id=my_cluster.id,
    type="g6-standard-2",
    node_count=3,
    tags=[external_pool_tag])

    package main

import (
	"github.com/pulumi/pulumi-linode/sdk/v5/go/linode"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		externalPoolTag := "external"
		my_cluster, err := linode.NewLkeCluster(ctx, "my-cluster", &linode.LkeClusterArgs{
			Label:      pulumi.String("my-cluster"),
			K8sVersion: pulumi.String("1.32"),
			Region:     pulumi.String("us-mia"),
			Labels: map[string]interface{}{
				"key": "value",
			},
			ExternalPoolTags: pulumi.StringArray{
				pulumi.String(pulumi.String(externalPoolTag)),
			},
			Pools: linode.LkeClusterPoolArray{
				&linode.LkeClusterPoolArgs{
					Type:  pulumi.String("g6-standard-1"),
					Count: pulumi.Int(1),
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = linode.NewLkeNodePool(ctx, "my-pool", &linode.LkeNodePoolArgs{
			ClusterId: my_cluster.ID(),
			Type:      pulumi.String("g6-standard-2"),
			NodeCount: pulumi.Int(3),
			Tags: pulumi.StringArray{
				pulumi.String(pulumi.String(externalPoolTag)),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var externalPoolTag = "external";

    var my_cluster = new Linode.LkeCluster("my-cluster", new()
    {
        Label = "my-cluster",
        K8sVersion = "1.32",
        Region = "us-mia",
        Labels = 
        {
            { "key", "value" },
        },
        ExternalPoolTags = new[]
        {
            externalPoolTag,
        },
        Pools = new[]
        {
            new Linode.Inputs.LkeClusterPoolArgs
            {
                Type = "g6-standard-1",
                Count = 1,
            },
        },
    });

    var my_pool = new Linode.LkeNodePool("my-pool", new()
    {
        ClusterId = my_cluster.Id,
        Type = "g6-standard-2",
        NodeCount = 3,
        Tags = new[]
        {
            externalPoolTag,
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.linode.LkeCluster;
import com.pulumi.linode.LkeClusterArgs;
import com.pulumi.linode.inputs.LkeClusterPoolArgs;
import com.pulumi.linode.LkeNodePool;
import com.pulumi.linode.LkeNodePoolArgs;
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) {
        final var externalPoolTag = "external";

        var my_cluster = new LkeCluster("my-cluster", LkeClusterArgs.builder()
            .label("my-cluster")
            .k8sVersion("1.32")
            .region("us-mia")
            .labels(Map.of("key", "value"))
            .externalPoolTags(externalPoolTag)
            .pools(LkeClusterPoolArgs.builder()
                .type("g6-standard-1")
                .count(1)
                .build())
            .build());

        var my_pool = new LkeNodePool("my-pool", LkeNodePoolArgs.builder()
            .clusterId(my_cluster.id())
            .type("g6-standard-2")
            .nodeCount(3)
            .tags(externalPoolTag)
            .build());

    }
}

    resources:
  my-pool:
    type: linode:LkeNodePool
    properties:
      clusterId: ${["my-cluster"].id}
      type: g6-standard-2
      nodeCount: 3
      tags:
        - ${externalPoolTag}
  my-cluster:
    type: linode:LkeCluster
    properties:
      label: my-cluster
      k8sVersion: '1.32'
      region: us-mia
      labels:
        key: value
      externalPoolTags:
        - ${externalPoolTag}
      pools:
        - type: g6-standard-1
          count: 1
variables:
  externalPoolTag: external

    Create LkeNodePool Resource

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

    Constructor syntax

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

@overload
def LkeNodePool(resource_name: str,
                opts: Optional[ResourceOptions] = None,
                cluster_id: Optional[int] = None,
                type: Optional[str] = None,
                autoscaler: Optional[LkeNodePoolAutoscalerArgs] = None,
                firewall_id: Optional[int] = None,
                k8s_version: Optional[str] = None,
                label: Optional[str] = None,
                labels: Optional[Mapping[str, str]] = None,
                node_count: Optional[int] = None,
                tags: Optional[Sequence[str]] = None,
                taints: Optional[Sequence[LkeNodePoolTaintArgs]] = None,
                update_strategy: Optional[str] = None)
    func NewLkeNodePool(ctx *Context, name string, args LkeNodePoolArgs, opts ...ResourceOption) (*LkeNodePool, error)
    public LkeNodePool(string name, LkeNodePoolArgs args, CustomResourceOptions? opts = null)
    public LkeNodePool(String name, LkeNodePoolArgs args)
public LkeNodePool(String name, LkeNodePoolArgs args, CustomResourceOptions options)

    type: linode:LkeNodePool
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 LkeNodePoolArgs
    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 LkeNodePoolArgs
    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 LkeNodePoolArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args LkeNodePoolArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args LkeNodePoolArgs
    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 lkeNodePoolResource = new Linode.Index.LkeNodePool("lkeNodePoolResource", new()
{
    ClusterId = 0,
    Type = "string",
    Autoscaler = new Linode.Inputs.LkeNodePoolAutoscalerArgs
    {
        Max = 0,
        Min = 0,
    },
    FirewallId = 0,
    K8sVersion = "string",
    Label = "string",
    Labels = 
    {
        { "string", "string" },
    },
    NodeCount = 0,
    Tags = new[]
    {
        "string",
    },
    Taints = new[]
    {
        new Linode.Inputs.LkeNodePoolTaintArgs
        {
            Effect = "string",
            Key = "string",
            Value = "string",
        },
    },
    UpdateStrategy = "string",
});

    example, err := linode.NewLkeNodePool(ctx, "lkeNodePoolResource", &linode.LkeNodePoolArgs{
	ClusterId: pulumi.Int(0),
	Type:      pulumi.String("string"),
	Autoscaler: &linode.LkeNodePoolAutoscalerArgs{
		Max: pulumi.Int(0),
		Min: pulumi.Int(0),
	},
	FirewallId: pulumi.Int(0),
	K8sVersion: pulumi.String("string"),
	Label:      pulumi.String("string"),
	Labels: pulumi.StringMap{
		"string": pulumi.String("string"),
	},
	NodeCount: pulumi.Int(0),
	Tags: pulumi.StringArray{
		pulumi.String("string"),
	},
	Taints: linode.LkeNodePoolTaintArray{
		&linode.LkeNodePoolTaintArgs{
			Effect: pulumi.String("string"),
			Key:    pulumi.String("string"),
			Value:  pulumi.String("string"),
		},
	},
	UpdateStrategy: pulumi.String("string"),
})

    var lkeNodePoolResource = new LkeNodePool("lkeNodePoolResource", LkeNodePoolArgs.builder()
    .clusterId(0)
    .type("string")
    .autoscaler(LkeNodePoolAutoscalerArgs.builder()
        .max(0)
        .min(0)
        .build())
    .firewallId(0)
    .k8sVersion("string")
    .label("string")
    .labels(Map.of("string", "string"))
    .nodeCount(0)
    .tags("string")
    .taints(LkeNodePoolTaintArgs.builder()
        .effect("string")
        .key("string")
        .value("string")
        .build())
    .updateStrategy("string")
    .build());

    lke_node_pool_resource = linode.LkeNodePool("lkeNodePoolResource",
    cluster_id=0,
    type="string",
    autoscaler={
        "max": 0,
        "min": 0,
    },
    firewall_id=0,
    k8s_version="string",
    label="string",
    labels={
        "string": "string",
    },
    node_count=0,
    tags=["string"],
    taints=[{
        "effect": "string",
        "key": "string",
        "value": "string",
    }],
    update_strategy="string")

    const lkeNodePoolResource = new linode.LkeNodePool("lkeNodePoolResource", {
    clusterId: 0,
    type: "string",
    autoscaler: {
        max: 0,
        min: 0,
    },
    firewallId: 0,
    k8sVersion: "string",
    label: "string",
    labels: {
        string: "string",
    },
    nodeCount: 0,
    tags: ["string"],
    taints: [{
        effect: "string",
        key: "string",
        value: "string",
    }],
    updateStrategy: "string",
});

    type: linode:LkeNodePool
properties:
    autoscaler:
        max: 0
        min: 0
    clusterId: 0
    firewallId: 0
    k8sVersion: string
    label: string
    labels:
        string: string
    nodeCount: 0
    tags:
        - string
    taints:
        - effect: string
          key: string
          value: string
    type: string
    updateStrategy: string

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

    ClusterId int
    ID of the LKE Cluster where to create the current Node Pool.
    Type string
    A Linode Type for all nodes in the Node Pool. See all node types here.
    Autoscaler LkeNodePoolAutoscaler
    FirewallId int
    The ID of the firewall to associate with this node pool. If not provided, default firewall will be associated.
    K8sVersion string
    The k8s version of the nodes in this node pool. For LKE enterprise only and may not currently available to all users even under v4beta.
    Label string
    A label for the Node Pool. If not provided, it defaults to empty string.
    Labels Dictionary<string, string>
    A map attribute containing key-value pairs to be added as labels to nodes in the node pool. Labels help classify your nodes and to easily select subsets of objects. To learn more, review Add Labels and Taints to your LKE Node Pools.
    NodeCount int
    The number of nodes in the Node Pool. If undefined with an autoscaler the initial node count will equal the autoscaler minimum.
    Tags List<string>
    An array of tags applied to the Node Pool. Tags can be used to flag node pools as externally managed, see Externally Managed Node Pools for more details.
    Taints List<LkeNodePoolTaint>
    Kubernetes taints to add to node pool nodes. Taints help control how pods are scheduled onto nodes, specifically allowing them to repel certain pods.
    UpdateStrategy string

    The strategy for updating the node pool k8s version. For LKE enterprise only and may not currently available to all users even under v4beta.

    • autoscaler - (Optional) If defined, an autoscaler will be enabled with the given configuration.

    • taint - (Optional) Kubernetes taints to add to node pool nodes. Taints help control how pods are scheduled onto nodes, specifically allowing them to repel certain pods. To learn more, review Add Labels and Taints to your LKE Node Pools.

    ClusterId int
    ID of the LKE Cluster where to create the current Node Pool.
    Type string
    A Linode Type for all nodes in the Node Pool. See all node types here.
    Autoscaler LkeNodePoolAutoscalerArgs
    FirewallId int
    The ID of the firewall to associate with this node pool. If not provided, default firewall will be associated.
    K8sVersion string
    The k8s version of the nodes in this node pool. For LKE enterprise only and may not currently available to all users even under v4beta.
    Label string
    A label for the Node Pool. If not provided, it defaults to empty string.
    Labels map[string]string
    A map attribute containing key-value pairs to be added as labels to nodes in the node pool. Labels help classify your nodes and to easily select subsets of objects. To learn more, review Add Labels and Taints to your LKE Node Pools.
    NodeCount int
    The number of nodes in the Node Pool. If undefined with an autoscaler the initial node count will equal the autoscaler minimum.
    Tags []string
    An array of tags applied to the Node Pool. Tags can be used to flag node pools as externally managed, see Externally Managed Node Pools for more details.
    Taints []LkeNodePoolTaintArgs
    Kubernetes taints to add to node pool nodes. Taints help control how pods are scheduled onto nodes, specifically allowing them to repel certain pods.
    UpdateStrategy string

    The strategy for updating the node pool k8s version. For LKE enterprise only and may not currently available to all users even under v4beta.

    • autoscaler - (Optional) If defined, an autoscaler will be enabled with the given configuration.

    • taint - (Optional) Kubernetes taints to add to node pool nodes. Taints help control how pods are scheduled onto nodes, specifically allowing them to repel certain pods. To learn more, review Add Labels and Taints to your LKE Node Pools.

    clusterId Integer
    ID of the LKE Cluster where to create the current Node Pool.
    type String
    A Linode Type for all nodes in the Node Pool. See all node types here.
    autoscaler LkeNodePoolAutoscaler
    firewallId Integer
    The ID of the firewall to associate with this node pool. If not provided, default firewall will be associated.
    k8sVersion String
    The k8s version of the nodes in this node pool. For LKE enterprise only and may not currently available to all users even under v4beta.
    label String
    A label for the Node Pool. If not provided, it defaults to empty string.
    labels Map<String,String>
    A map attribute containing key-value pairs to be added as labels to nodes in the node pool. Labels help classify your nodes and to easily select subsets of objects. To learn more, review Add Labels and Taints to your LKE Node Pools.
    nodeCount Integer
    The number of nodes in the Node Pool. If undefined with an autoscaler the initial node count will equal the autoscaler minimum.
    tags List<String>
    An array of tags applied to the Node Pool. Tags can be used to flag node pools as externally managed, see Externally Managed Node Pools for more details.
    taints List<LkeNodePoolTaint>
    Kubernetes taints to add to node pool nodes. Taints help control how pods are scheduled onto nodes, specifically allowing them to repel certain pods.
    updateStrategy String

    The strategy for updating the node pool k8s version. For LKE enterprise only and may not currently available to all users even under v4beta.

    • autoscaler - (Optional) If defined, an autoscaler will be enabled with the given configuration.

    • taint - (Optional) Kubernetes taints to add to node pool nodes. Taints help control how pods are scheduled onto nodes, specifically allowing them to repel certain pods. To learn more, review Add Labels and Taints to your LKE Node Pools.

    clusterId number
    ID of the LKE Cluster where to create the current Node Pool.
    type string
    A Linode Type for all nodes in the Node Pool. See all node types here.
    autoscaler LkeNodePoolAutoscaler
    firewallId number
    The ID of the firewall to associate with this node pool. If not provided, default firewall will be associated.
    k8sVersion string
    The k8s version of the nodes in this node pool. For LKE enterprise only and may not currently available to all users even under v4beta.
    label string
    A label for the Node Pool. If not provided, it defaults to empty string.
    labels {[key: string]: string}
    A map attribute containing key-value pairs to be added as labels to nodes in the node pool. Labels help classify your nodes and to easily select subsets of objects. To learn more, review Add Labels and Taints to your LKE Node Pools.
    nodeCount number
    The number of nodes in the Node Pool. If undefined with an autoscaler the initial node count will equal the autoscaler minimum.
    tags string[]
    An array of tags applied to the Node Pool. Tags can be used to flag node pools as externally managed, see Externally Managed Node Pools for more details.
    taints LkeNodePoolTaint[]
    Kubernetes taints to add to node pool nodes. Taints help control how pods are scheduled onto nodes, specifically allowing them to repel certain pods.
    updateStrategy string

    The strategy for updating the node pool k8s version. For LKE enterprise only and may not currently available to all users even under v4beta.

    • autoscaler - (Optional) If defined, an autoscaler will be enabled with the given configuration.

    • taint - (Optional) Kubernetes taints to add to node pool nodes. Taints help control how pods are scheduled onto nodes, specifically allowing them to repel certain pods. To learn more, review Add Labels and Taints to your LKE Node Pools.

    cluster_id int
    ID of the LKE Cluster where to create the current Node Pool.
    type str
    A Linode Type for all nodes in the Node Pool. See all node types here.
    autoscaler LkeNodePoolAutoscalerArgs
    firewall_id int
    The ID of the firewall to associate with this node pool. If not provided, default firewall will be associated.
    k8s_version str
    The k8s version of the nodes in this node pool. For LKE enterprise only and may not currently available to all users even under v4beta.
    label str
    A label for the Node Pool. If not provided, it defaults to empty string.
    labels Mapping[str, str]
    A map attribute containing key-value pairs to be added as labels to nodes in the node pool. Labels help classify your nodes and to easily select subsets of objects. To learn more, review Add Labels and Taints to your LKE Node Pools.
    node_count int
    The number of nodes in the Node Pool. If undefined with an autoscaler the initial node count will equal the autoscaler minimum.
    tags Sequence[str]
    An array of tags applied to the Node Pool. Tags can be used to flag node pools as externally managed, see Externally Managed Node Pools for more details.
    taints Sequence[LkeNodePoolTaintArgs]
    Kubernetes taints to add to node pool nodes. Taints help control how pods are scheduled onto nodes, specifically allowing them to repel certain pods.
    update_strategy str

    The strategy for updating the node pool k8s version. For LKE enterprise only and may not currently available to all users even under v4beta.

    • autoscaler - (Optional) If defined, an autoscaler will be enabled with the given configuration.

    • taint - (Optional) Kubernetes taints to add to node pool nodes. Taints help control how pods are scheduled onto nodes, specifically allowing them to repel certain pods. To learn more, review Add Labels and Taints to your LKE Node Pools.

    clusterId Number
    ID of the LKE Cluster where to create the current Node Pool.
    type String
    A Linode Type for all nodes in the Node Pool. See all node types here.
    autoscaler Property Map
    firewallId Number
    The ID of the firewall to associate with this node pool. If not provided, default firewall will be associated.
    k8sVersion String
    The k8s version of the nodes in this node pool. For LKE enterprise only and may not currently available to all users even under v4beta.
    label String
    A label for the Node Pool. If not provided, it defaults to empty string.
    labels Map<String>
    A map attribute containing key-value pairs to be added as labels to nodes in the node pool. Labels help classify your nodes and to easily select subsets of objects. To learn more, review Add Labels and Taints to your LKE Node Pools.
    nodeCount Number
    The number of nodes in the Node Pool. If undefined with an autoscaler the initial node count will equal the autoscaler minimum.
    tags List<String>
    An array of tags applied to the Node Pool. Tags can be used to flag node pools as externally managed, see Externally Managed Node Pools for more details.
    taints List<Property Map>
    Kubernetes taints to add to node pool nodes. Taints help control how pods are scheduled onto nodes, specifically allowing them to repel certain pods.
    updateStrategy String

    The strategy for updating the node pool k8s version. For LKE enterprise only and may not currently available to all users even under v4beta.

    • autoscaler - (Optional) If defined, an autoscaler will be enabled with the given configuration.

    • taint - (Optional) Kubernetes taints to add to node pool nodes. Taints help control how pods are scheduled onto nodes, specifically allowing them to repel certain pods. To learn more, review Add Labels and Taints to your LKE Node Pools.

    Outputs

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

    DiskEncryption string
    The disk encryption policy for nodes in this pool.
    Id string
    The provider-assigned unique ID for this managed resource.
    Nodes List<LkeNodePoolNode>
    A list of nodes in the node pool.
    DiskEncryption string
    The disk encryption policy for nodes in this pool.
    Id string
    The provider-assigned unique ID for this managed resource.
    Nodes []LkeNodePoolNode
    A list of nodes in the node pool.
    diskEncryption String
    The disk encryption policy for nodes in this pool.
    id String
    The provider-assigned unique ID for this managed resource.
    nodes List<LkeNodePoolNode>
    A list of nodes in the node pool.
    diskEncryption string
    The disk encryption policy for nodes in this pool.
    id string
    The provider-assigned unique ID for this managed resource.
    nodes LkeNodePoolNode[]
    A list of nodes in the node pool.
    disk_encryption str
    The disk encryption policy for nodes in this pool.
    id str
    The provider-assigned unique ID for this managed resource.
    nodes Sequence[LkeNodePoolNode]
    A list of nodes in the node pool.
    diskEncryption String
    The disk encryption policy for nodes in this pool.
    id String
    The provider-assigned unique ID for this managed resource.
    nodes List<Property Map>
    A list of nodes in the node pool.

    Look up Existing LkeNodePool Resource

    Get an existing LkeNodePool 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?: LkeNodePoolState, opts?: CustomResourceOptions): LkeNodePool
    @staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        autoscaler: Optional[LkeNodePoolAutoscalerArgs] = None,
        cluster_id: Optional[int] = None,
        disk_encryption: Optional[str] = None,
        firewall_id: Optional[int] = None,
        k8s_version: Optional[str] = None,
        label: Optional[str] = None,
        labels: Optional[Mapping[str, str]] = None,
        node_count: Optional[int] = None,
        nodes: Optional[Sequence[LkeNodePoolNodeArgs]] = None,
        tags: Optional[Sequence[str]] = None,
        taints: Optional[Sequence[LkeNodePoolTaintArgs]] = None,
        type: Optional[str] = None,
        update_strategy: Optional[str] = None) -> LkeNodePool
    func GetLkeNodePool(ctx *Context, name string, id IDInput, state *LkeNodePoolState, opts ...ResourceOption) (*LkeNodePool, error)
    public static LkeNodePool Get(string name, Input<string> id, LkeNodePoolState? state, CustomResourceOptions? opts = null)
    public static LkeNodePool get(String name, Output<String> id, LkeNodePoolState state, CustomResourceOptions options)
    resources:  _:    type: linode:LkeNodePool    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:
    Autoscaler LkeNodePoolAutoscaler
    ClusterId int
    ID of the LKE Cluster where to create the current Node Pool.
    DiskEncryption string
    The disk encryption policy for nodes in this pool.
    FirewallId int
    The ID of the firewall to associate with this node pool. If not provided, default firewall will be associated.
    K8sVersion string
    The k8s version of the nodes in this node pool. For LKE enterprise only and may not currently available to all users even under v4beta.
    Label string
    A label for the Node Pool. If not provided, it defaults to empty string.
    Labels Dictionary<string, string>
    A map attribute containing key-value pairs to be added as labels to nodes in the node pool. Labels help classify your nodes and to easily select subsets of objects. To learn more, review Add Labels and Taints to your LKE Node Pools.
    NodeCount int
    The number of nodes in the Node Pool. If undefined with an autoscaler the initial node count will equal the autoscaler minimum.
    Nodes List<LkeNodePoolNode>
    A list of nodes in the node pool.
    Tags List<string>
    An array of tags applied to the Node Pool. Tags can be used to flag node pools as externally managed, see Externally Managed Node Pools for more details.
    Taints List<LkeNodePoolTaint>
    Kubernetes taints to add to node pool nodes. Taints help control how pods are scheduled onto nodes, specifically allowing them to repel certain pods.
    Type string
    A Linode Type for all nodes in the Node Pool. See all node types here.
    UpdateStrategy string

    The strategy for updating the node pool k8s version. For LKE enterprise only and may not currently available to all users even under v4beta.

    • autoscaler - (Optional) If defined, an autoscaler will be enabled with the given configuration.

    • taint - (Optional) Kubernetes taints to add to node pool nodes. Taints help control how pods are scheduled onto nodes, specifically allowing them to repel certain pods. To learn more, review Add Labels and Taints to your LKE Node Pools.

    Autoscaler LkeNodePoolAutoscalerArgs
    ClusterId int
    ID of the LKE Cluster where to create the current Node Pool.
    DiskEncryption string
    The disk encryption policy for nodes in this pool.
    FirewallId int
    The ID of the firewall to associate with this node pool. If not provided, default firewall will be associated.
    K8sVersion string
    The k8s version of the nodes in this node pool. For LKE enterprise only and may not currently available to all users even under v4beta.
    Label string
    A label for the Node Pool. If not provided, it defaults to empty string.
    Labels map[string]string
    A map attribute containing key-value pairs to be added as labels to nodes in the node pool. Labels help classify your nodes and to easily select subsets of objects. To learn more, review Add Labels and Taints to your LKE Node Pools.
    NodeCount int
    The number of nodes in the Node Pool. If undefined with an autoscaler the initial node count will equal the autoscaler minimum.
    Nodes []LkeNodePoolNodeArgs
    A list of nodes in the node pool.
    Tags []string
    An array of tags applied to the Node Pool. Tags can be used to flag node pools as externally managed, see Externally Managed Node Pools for more details.
    Taints []LkeNodePoolTaintArgs
    Kubernetes taints to add to node pool nodes. Taints help control how pods are scheduled onto nodes, specifically allowing them to repel certain pods.
    Type string
    A Linode Type for all nodes in the Node Pool. See all node types here.
    UpdateStrategy string

    The strategy for updating the node pool k8s version. For LKE enterprise only and may not currently available to all users even under v4beta.

    • autoscaler - (Optional) If defined, an autoscaler will be enabled with the given configuration.

    • taint - (Optional) Kubernetes taints to add to node pool nodes. Taints help control how pods are scheduled onto nodes, specifically allowing them to repel certain pods. To learn more, review Add Labels and Taints to your LKE Node Pools.

    autoscaler LkeNodePoolAutoscaler
    clusterId Integer
    ID of the LKE Cluster where to create the current Node Pool.
    diskEncryption String
    The disk encryption policy for nodes in this pool.
    firewallId Integer
    The ID of the firewall to associate with this node pool. If not provided, default firewall will be associated.
    k8sVersion String
    The k8s version of the nodes in this node pool. For LKE enterprise only and may not currently available to all users even under v4beta.
    label String
    A label for the Node Pool. If not provided, it defaults to empty string.
    labels Map<String,String>
    A map attribute containing key-value pairs to be added as labels to nodes in the node pool. Labels help classify your nodes and to easily select subsets of objects. To learn more, review Add Labels and Taints to your LKE Node Pools.
    nodeCount Integer
    The number of nodes in the Node Pool. If undefined with an autoscaler the initial node count will equal the autoscaler minimum.
    nodes List<LkeNodePoolNode>
    A list of nodes in the node pool.
    tags List<String>
    An array of tags applied to the Node Pool. Tags can be used to flag node pools as externally managed, see Externally Managed Node Pools for more details.
    taints List<LkeNodePoolTaint>
    Kubernetes taints to add to node pool nodes. Taints help control how pods are scheduled onto nodes, specifically allowing them to repel certain pods.
    type String
    A Linode Type for all nodes in the Node Pool. See all node types here.
    updateStrategy String

    The strategy for updating the node pool k8s version. For LKE enterprise only and may not currently available to all users even under v4beta.

    • autoscaler - (Optional) If defined, an autoscaler will be enabled with the given configuration.

    • taint - (Optional) Kubernetes taints to add to node pool nodes. Taints help control how pods are scheduled onto nodes, specifically allowing them to repel certain pods. To learn more, review Add Labels and Taints to your LKE Node Pools.

    autoscaler LkeNodePoolAutoscaler
    clusterId number
    ID of the LKE Cluster where to create the current Node Pool.
    diskEncryption string
    The disk encryption policy for nodes in this pool.
    firewallId number
    The ID of the firewall to associate with this node pool. If not provided, default firewall will be associated.
    k8sVersion string
    The k8s version of the nodes in this node pool. For LKE enterprise only and may not currently available to all users even under v4beta.
    label string
    A label for the Node Pool. If not provided, it defaults to empty string.
    labels {[key: string]: string}
    A map attribute containing key-value pairs to be added as labels to nodes in the node pool. Labels help classify your nodes and to easily select subsets of objects. To learn more, review Add Labels and Taints to your LKE Node Pools.
    nodeCount number
    The number of nodes in the Node Pool. If undefined with an autoscaler the initial node count will equal the autoscaler minimum.
    nodes LkeNodePoolNode[]
    A list of nodes in the node pool.
    tags string[]
    An array of tags applied to the Node Pool. Tags can be used to flag node pools as externally managed, see Externally Managed Node Pools for more details.
    taints LkeNodePoolTaint[]
    Kubernetes taints to add to node pool nodes. Taints help control how pods are scheduled onto nodes, specifically allowing them to repel certain pods.
    type string
    A Linode Type for all nodes in the Node Pool. See all node types here.
    updateStrategy string

    The strategy for updating the node pool k8s version. For LKE enterprise only and may not currently available to all users even under v4beta.

    • autoscaler - (Optional) If defined, an autoscaler will be enabled with the given configuration.

    • taint - (Optional) Kubernetes taints to add to node pool nodes. Taints help control how pods are scheduled onto nodes, specifically allowing them to repel certain pods. To learn more, review Add Labels and Taints to your LKE Node Pools.

    autoscaler LkeNodePoolAutoscalerArgs
    cluster_id int
    ID of the LKE Cluster where to create the current Node Pool.
    disk_encryption str
    The disk encryption policy for nodes in this pool.
    firewall_id int
    The ID of the firewall to associate with this node pool. If not provided, default firewall will be associated.
    k8s_version str
    The k8s version of the nodes in this node pool. For LKE enterprise only and may not currently available to all users even under v4beta.
    label str
    A label for the Node Pool. If not provided, it defaults to empty string.
    labels Mapping[str, str]
    A map attribute containing key-value pairs to be added as labels to nodes in the node pool. Labels help classify your nodes and to easily select subsets of objects. To learn more, review Add Labels and Taints to your LKE Node Pools.
    node_count int
    The number of nodes in the Node Pool. If undefined with an autoscaler the initial node count will equal the autoscaler minimum.
    nodes Sequence[LkeNodePoolNodeArgs]
    A list of nodes in the node pool.
    tags Sequence[str]
    An array of tags applied to the Node Pool. Tags can be used to flag node pools as externally managed, see Externally Managed Node Pools for more details.
    taints Sequence[LkeNodePoolTaintArgs]
    Kubernetes taints to add to node pool nodes. Taints help control how pods are scheduled onto nodes, specifically allowing them to repel certain pods.
    type str
    A Linode Type for all nodes in the Node Pool. See all node types here.
    update_strategy str

    The strategy for updating the node pool k8s version. For LKE enterprise only and may not currently available to all users even under v4beta.

    • autoscaler - (Optional) If defined, an autoscaler will be enabled with the given configuration.

    • taint - (Optional) Kubernetes taints to add to node pool nodes. Taints help control how pods are scheduled onto nodes, specifically allowing them to repel certain pods. To learn more, review Add Labels and Taints to your LKE Node Pools.

    autoscaler Property Map
    clusterId Number
    ID of the LKE Cluster where to create the current Node Pool.
    diskEncryption String
    The disk encryption policy for nodes in this pool.
    firewallId Number
    The ID of the firewall to associate with this node pool. If not provided, default firewall will be associated.
    k8sVersion String
    The k8s version of the nodes in this node pool. For LKE enterprise only and may not currently available to all users even under v4beta.
    label String
    A label for the Node Pool. If not provided, it defaults to empty string.
    labels Map<String>
    A map attribute containing key-value pairs to be added as labels to nodes in the node pool. Labels help classify your nodes and to easily select subsets of objects. To learn more, review Add Labels and Taints to your LKE Node Pools.
    nodeCount Number
    The number of nodes in the Node Pool. If undefined with an autoscaler the initial node count will equal the autoscaler minimum.
    nodes List<Property Map>
    A list of nodes in the node pool.
    tags List<String>
    An array of tags applied to the Node Pool. Tags can be used to flag node pools as externally managed, see Externally Managed Node Pools for more details.
    taints List<Property Map>
    Kubernetes taints to add to node pool nodes. Taints help control how pods are scheduled onto nodes, specifically allowing them to repel certain pods.
    type String
    A Linode Type for all nodes in the Node Pool. See all node types here.
    updateStrategy String

    The strategy for updating the node pool k8s version. For LKE enterprise only and may not currently available to all users even under v4beta.

    • autoscaler - (Optional) If defined, an autoscaler will be enabled with the given configuration.

    • taint - (Optional) Kubernetes taints to add to node pool nodes. Taints help control how pods are scheduled onto nodes, specifically allowing them to repel certain pods. To learn more, review Add Labels and Taints to your LKE Node Pools.

    Supporting Types

    LkeNodePoolAutoscaler, LkeNodePoolAutoscalerArgs

    Max int
    The maximum number of nodes to autoscale to.
    Min int
    The minimum number of nodes to autoscale to.
    Max int
    The maximum number of nodes to autoscale to.
    Min int
    The minimum number of nodes to autoscale to.
    max Integer
    The maximum number of nodes to autoscale to.
    min Integer
    The minimum number of nodes to autoscale to.
    max number
    The maximum number of nodes to autoscale to.
    min number
    The minimum number of nodes to autoscale to.
    max int
    The maximum number of nodes to autoscale to.
    min int
    The minimum number of nodes to autoscale to.
    max Number
    The maximum number of nodes to autoscale to.
    min Number
    The minimum number of nodes to autoscale to.

    LkeNodePoolNode, LkeNodePoolNodeArgs

    Id string
    The ID of the node.
    InstanceId int
    The ID of the underlying Linode instance.
    Status string
    The status of the node. (ready, notReady)
    Id string
    The ID of the node.
    InstanceId int
    The ID of the underlying Linode instance.
    Status string
    The status of the node. (ready, notReady)
    id String
    The ID of the node.
    instanceId Integer
    The ID of the underlying Linode instance.
    status String
    The status of the node. (ready, notReady)
    id string
    The ID of the node.
    instanceId number
    The ID of the underlying Linode instance.
    status string
    The status of the node. (ready, notReady)
    id str
    The ID of the node.
    instance_id int
    The ID of the underlying Linode instance.
    status str
    The status of the node. (ready, notReady)
    id String
    The ID of the node.
    instanceId Number
    The ID of the underlying Linode instance.
    status String
    The status of the node. (ready, notReady)

    LkeNodePoolTaint, LkeNodePoolTaintArgs

    Effect string
    The Kubernetes taint effect. Accepted values are NoSchedule, PreferNoSchedule, and NoExecute. For the descriptions of these values, see Kubernetes Taints and Tolerations.
    Key string
    The Kubernetes taint key.
    Value string
    The Kubernetes taint value.
    Effect string
    The Kubernetes taint effect. Accepted values are NoSchedule, PreferNoSchedule, and NoExecute. For the descriptions of these values, see Kubernetes Taints and Tolerations.
    Key string
    The Kubernetes taint key.
    Value string
    The Kubernetes taint value.
    effect String
    The Kubernetes taint effect. Accepted values are NoSchedule, PreferNoSchedule, and NoExecute. For the descriptions of these values, see Kubernetes Taints and Tolerations.
    key String
    The Kubernetes taint key.
    value String
    The Kubernetes taint value.
    effect string
    The Kubernetes taint effect. Accepted values are NoSchedule, PreferNoSchedule, and NoExecute. For the descriptions of these values, see Kubernetes Taints and Tolerations.
    key string
    The Kubernetes taint key.
    value string
    The Kubernetes taint value.
    effect str
    The Kubernetes taint effect. Accepted values are NoSchedule, PreferNoSchedule, and NoExecute. For the descriptions of these values, see Kubernetes Taints and Tolerations.
    key str
    The Kubernetes taint key.
    value str
    The Kubernetes taint value.
    effect String
    The Kubernetes taint effect. Accepted values are NoSchedule, PreferNoSchedule, and NoExecute. For the descriptions of these values, see Kubernetes Taints and Tolerations.
    key String
    The Kubernetes taint key.
    value String
    The Kubernetes taint value.

    Import

    LKE Node Pools can be imported using the cluster_id,id, e.g.

    $ pulumi import linode:index/lkeNodePool:LkeNodePool my_pool 150003,12345

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

    Package Details

    Repository
    Linode pulumi/pulumi-linode
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the linode Terraform Provider.
    linode logo
    Viewing docs for Linode v5.10.0
    published on Wednesday, Apr 1, 2026 by Pulumi
    Schema (JSON)
    pulumi/pulumi-linode
      Try Pulumi Cloud free. Your team will thank you.