Docs Packages
  1. Packages
  2. Linode
  3. API Docs
  4. LkeNodePool
Linode v4.19.0 published on Wednesday, Apr 24, 2024 by Pulumi
pulumi/pulumi-linode

linode.LkeNodePool

Explore with Pulumi AI

linode logo
Linode v4.19.0 published on Wednesday, Apr 24, 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,
                node_count: Optional[int] = None,
                tags: Optional[Sequence[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.

    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,
    },
    NodeCount = 0,
    Tags = new[]
    {
        "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),
	},
	NodeCount: pulumi.Int(0),
	Tags: pulumi.StringArray{
		pulumi.String("string"),
	},
})

    var lkeNodePoolResource = new LkeNodePool("lkeNodePoolResource", LkeNodePoolArgs.builder()        
    .clusterId(0)
    .type("string")
    .autoscaler(LkeNodePoolAutoscalerArgs.builder()
        .max(0)
        .min(0)
        .build())
    .nodeCount(0)
    .tags("string")
    .build());

    lke_node_pool_resource = linode.LkeNodePool("lkeNodePoolResource",
    cluster_id=0,
    type="string",
    autoscaler=linode.LkeNodePoolAutoscalerArgs(
        max=0,
        min=0,
    ),
    node_count=0,
    tags=["string"])

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

    type: linode:LkeNodePool
properties:
    autoscaler:
        max: 0
        min: 0
    clusterId: 0
    nodeCount: 0
    tags:
        - 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

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

    • autoscaler - (Optional) If defined, an autoscaler will be enabled with the given configuration.
    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
    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.

    • autoscaler - (Optional) If defined, an autoscaler will be enabled with the given configuration.
    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
    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.

    • autoscaler - (Optional) If defined, an autoscaler will be enabled with the given configuration.
    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
    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.

    • autoscaler - (Optional) If defined, an autoscaler will be enabled with the given configuration.
    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
    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.

    • autoscaler - (Optional) If defined, an autoscaler will be enabled with the given configuration.
    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
    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.

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

    Outputs

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

    Id string
    The provider-assigned unique ID for this managed resource.
    Nodes List<LkeNodePoolNode>
    A list of nodes in the node pool.
    Id string
    The provider-assigned unique ID for this managed resource.
    Nodes []LkeNodePoolNode
    A list of nodes in the node pool.
    id String
    The provider-assigned unique ID for this managed resource.
    nodes List<LkeNodePoolNode>
    A list of nodes in the node pool.
    id string
    The provider-assigned unique ID for this managed resource.
    nodes LkeNodePoolNode[]
    A list of nodes in the node pool.
    id str
    The provider-assigned unique ID for this managed resource.
    nodes Sequence[LkeNodePoolNode]
    A list of nodes in the node 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,
        node_count: Optional[int] = None,
        nodes: Optional[Sequence[LkeNodePoolNodeArgs]] = None,
        tags: Optional[Sequence[str]] = 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.
    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.

    • autoscaler - (Optional) If defined, an autoscaler will be enabled with the given configuration.
    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.
    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.

    • autoscaler - (Optional) If defined, an autoscaler will be enabled with the given configuration.
    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.
    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.

    • autoscaler - (Optional) If defined, an autoscaler will be enabled with the given configuration.
    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.
    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.

    • autoscaler - (Optional) If defined, an autoscaler will be enabled with the given configuration.
    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.
    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.

    • autoscaler - (Optional) If defined, an autoscaler will be enabled with the given configuration.
    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.
    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.

    • autoscaler - (Optional) If defined, an autoscaler will be enabled with the given configuration.
    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)

    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.19.0 published on Wednesday, Apr 24, 2024 by Pulumi
    pulumi/pulumi-linode