Docs Home Pulumi IaC Pulumi ESC Pulumi Cloud Packages Tutorials
  1. Packages
  2. Linode Provider
  3. API Docs
  4. LkeNodePool
Linode v4.30.0 published on Friday, Nov 8, 2024 by Pulumi
pulumi/pulumi-linode

linode.LkeNodePool

Explore with Pulumi AI

linode logo
Linode v4.30.0 published on Friday, Nov 8, 2024 by Pulumi
pulumi/pulumi-linode

    Import

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

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

    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,
                labels: Optional[Mapping[str, str]] = None,
                node_count: Optional[int] = None,
                tags: Optional[Sequence[str]] = None,
                taints: Optional[Sequence[LkeNodePoolTaintArgs]] = 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.LkeNodePool("lkeNodePoolResource", new()
{
    ClusterId = 0,
    Type = "string",
    Autoscaler = new Linode.Inputs.LkeNodePoolAutoscalerArgs
    {
        Max = 0,
        Min = 0,
    },
    Labels = 
    {
        { "string", "string" },
    },
    NodeCount = 0,
    Tags = new[]
    {
        "string",
    },
    Taints = new[]
    {
        new Linode.Inputs.LkeNodePoolTaintArgs
        {
            Effect = "string",
            Key = "string",
            Value = "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),
	},
	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"),
		},
	},
})

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

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

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

    type: linode:LkeNodePool
properties:
    autoscaler:
        max: 0
        min: 0
    clusterId: 0
    labels:
        string: string
    nodeCount: 0
    tags:
        - string
    taints:
        - effect: string
          key: string
          value: string
    type: 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
    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.

    • 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.

    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.
    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
    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.

    • 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.

    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.
    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
    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.

    • 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.

    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.
    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
    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.

    • 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.

    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.
    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
    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.

    • 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.

    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.
    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
    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.

    • 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.

    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.

    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,
        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) -> 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)
    Resource lookup is not supported in YAML
    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.
    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.

    • 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.

    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.
    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.
    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.

    • 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.

    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.
    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.
    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.

    • 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.

    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.
    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.
    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.

    • 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.

    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.
    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.
    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.

    • 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.

    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.
    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.
    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.

    • 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.

    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.

    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, not_ready)
    Id string
    The ID of the node.
    InstanceId int
    The ID of the underlying Linode instance.
    Status string
    The status of the node. (ready, not_ready)
    id String
    The ID of the node.
    instanceId Integer
    The ID of the underlying Linode instance.
    status String
    The status of the node. (ready, not_ready)
    id string
    The ID of the node.
    instanceId number
    The ID of the underlying Linode instance.
    status string
    The status of the node. (ready, not_ready)
    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, not_ready)
    id String
    The ID of the node.
    instanceId Number
    The ID of the underlying Linode instance.
    status String
    The status of the node. (ready, not_ready)

    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.

    Package Details

    Repository
    Linode pulumi/pulumi-linode
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the linode Terraform Provider.
    linode logo
    Linode v4.30.0 published on Friday, Nov 8, 2024 by Pulumi
    pulumi/pulumi-linode