1. Packages
  2. OVH
  3. API Docs
  4. CloudProject
  5. KubeNodePool
OVHCloud v1.1.0 published on Thursday, Nov 21, 2024 by OVHcloud

ovh.CloudProject.KubeNodePool

Explore with Pulumi AI

ovh logo
OVHCloud v1.1.0 published on Thursday, Nov 21, 2024 by OVHcloud

    Creates a nodepool in a OVHcloud Managed Kubernetes Service cluster.

    Example Usage

    Create a simple node pool in your Kubernetes cluster:

    import * as pulumi from "@pulumi/pulumi";
    import * as ovh from "@ovhcloud/pulumi-ovh";
    
    const nodePool = new ovh.cloudproject.KubeNodePool("nodePool", {
        desiredNodes: 3,
        flavorName: "b2-7",
        kubeId: "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
        maxNodes: 3,
        minNodes: 3,
        serviceName: "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
    });
    
    import pulumi
    import pulumi_ovh as ovh
    
    node_pool = ovh.cloud_project.KubeNodePool("nodePool",
        desired_nodes=3,
        flavor_name="b2-7",
        kube_id="xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
        max_nodes=3,
        min_nodes=3,
        service_name="xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx")
    
    package main
    
    import (
    	"github.com/ovh/pulumi-ovh/sdk/go/ovh/CloudProject"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		_, err := CloudProject.NewKubeNodePool(ctx, "nodePool", &CloudProject.KubeNodePoolArgs{
    			DesiredNodes: pulumi.Int(3),
    			FlavorName:   pulumi.String("b2-7"),
    			KubeId:       pulumi.String("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"),
    			MaxNodes:     pulumi.Int(3),
    			MinNodes:     pulumi.Int(3),
    			ServiceName:  pulumi.String("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"),
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Ovh = Pulumi.Ovh;
    
    return await Deployment.RunAsync(() => 
    {
        var nodePool = new Ovh.CloudProject.KubeNodePool("nodePool", new()
        {
            DesiredNodes = 3,
            FlavorName = "b2-7",
            KubeId = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
            MaxNodes = 3,
            MinNodes = 3,
            ServiceName = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
        });
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.ovh.CloudProject.KubeNodePool;
    import com.pulumi.ovh.CloudProject.KubeNodePoolArgs;
    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 nodePool = new KubeNodePool("nodePool", KubeNodePoolArgs.builder()
                .desiredNodes(3)
                .flavorName("b2-7")
                .kubeId("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx")
                .maxNodes(3)
                .minNodes(3)
                .serviceName("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx")
                .build());
    
        }
    }
    
    resources:
      nodePool:
        type: ovh:CloudProject:KubeNodePool
        properties:
          desiredNodes: 3
          flavorName: b2-7
          kubeId: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
          maxNodes: 3
          minNodes: 3
          # Warning: "_" char is not allowed!
          serviceName: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
    

    Create an advanced node pool in your Kubernetes cluster:

    import * as pulumi from "@pulumi/pulumi";
    import * as ovh from "@ovhcloud/pulumi-ovh";
    
    const pool = new ovh.cloudproject.KubeNodePool("pool", {
        desiredNodes: 3,
        flavorName: "b2-7",
        kubeId: "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
        maxNodes: 3,
        minNodes: 3,
        serviceName: "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
        template: {
            metadata: {
                annotations: {
                    k1: "v1",
                    k2: "v2",
                },
                finalizers: [],
                labels: {
                    k3: "v3",
                    k4: "v4",
                },
            },
            spec: {
                taints: [{
                    effect: "PreferNoSchedule",
                    key: "k",
                    value: "v",
                }],
                unschedulable: false,
            },
        },
    });
    
    import pulumi
    import pulumi_ovh as ovh
    
    pool = ovh.cloud_project.KubeNodePool("pool",
        desired_nodes=3,
        flavor_name="b2-7",
        kube_id="xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
        max_nodes=3,
        min_nodes=3,
        service_name="xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
        template={
            "metadata": {
                "annotations": {
                    "k1": "v1",
                    "k2": "v2",
                },
                "finalizers": [],
                "labels": {
                    "k3": "v3",
                    "k4": "v4",
                },
            },
            "spec": {
                "taints": [{
                    "effect": "PreferNoSchedule",
                    "key": "k",
                    "value": "v",
                }],
                "unschedulable": False,
            },
        })
    
    package main
    
    import (
    	"github.com/ovh/pulumi-ovh/sdk/go/ovh/CloudProject"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		_, err := CloudProject.NewKubeNodePool(ctx, "pool", &CloudProject.KubeNodePoolArgs{
    			DesiredNodes: pulumi.Int(3),
    			FlavorName:   pulumi.String("b2-7"),
    			KubeId:       pulumi.String("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"),
    			MaxNodes:     pulumi.Int(3),
    			MinNodes:     pulumi.Int(3),
    			ServiceName:  pulumi.String("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"),
    			Template: &cloudproject.KubeNodePoolTemplateArgs{
    				Metadata: &cloudproject.KubeNodePoolTemplateMetadataArgs{
    					Annotations: pulumi.StringMap{
    						"k1": pulumi.String("v1"),
    						"k2": pulumi.String("v2"),
    					},
    					Finalizers: pulumi.StringArray{},
    					Labels: pulumi.StringMap{
    						"k3": pulumi.String("v3"),
    						"k4": pulumi.String("v4"),
    					},
    				},
    				Spec: &cloudproject.KubeNodePoolTemplateSpecArgs{
    					Taints: pulumi.StringMapArray{
    						pulumi.StringMap{
    							"effect": pulumi.String("PreferNoSchedule"),
    							"key":    pulumi.String("k"),
    							"value":  pulumi.String("v"),
    						},
    					},
    					Unschedulable: pulumi.Bool(false),
    				},
    			},
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Ovh = Pulumi.Ovh;
    
    return await Deployment.RunAsync(() => 
    {
        var pool = new Ovh.CloudProject.KubeNodePool("pool", new()
        {
            DesiredNodes = 3,
            FlavorName = "b2-7",
            KubeId = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
            MaxNodes = 3,
            MinNodes = 3,
            ServiceName = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
            Template = new Ovh.CloudProject.Inputs.KubeNodePoolTemplateArgs
            {
                Metadata = new Ovh.CloudProject.Inputs.KubeNodePoolTemplateMetadataArgs
                {
                    Annotations = 
                    {
                        { "k1", "v1" },
                        { "k2", "v2" },
                    },
                    Finalizers = new() { },
                    Labels = 
                    {
                        { "k3", "v3" },
                        { "k4", "v4" },
                    },
                },
                Spec = new Ovh.CloudProject.Inputs.KubeNodePoolTemplateSpecArgs
                {
                    Taints = new[]
                    {
                        
                        {
                            { "effect", "PreferNoSchedule" },
                            { "key", "k" },
                            { "value", "v" },
                        },
                    },
                    Unschedulable = false,
                },
            },
        });
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.ovh.CloudProject.KubeNodePool;
    import com.pulumi.ovh.CloudProject.KubeNodePoolArgs;
    import com.pulumi.ovh.CloudProject.inputs.KubeNodePoolTemplateArgs;
    import com.pulumi.ovh.CloudProject.inputs.KubeNodePoolTemplateMetadataArgs;
    import com.pulumi.ovh.CloudProject.inputs.KubeNodePoolTemplateSpecArgs;
    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 pool = new KubeNodePool("pool", KubeNodePoolArgs.builder()
                .desiredNodes(3)
                .flavorName("b2-7")
                .kubeId("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx")
                .maxNodes(3)
                .minNodes(3)
                .serviceName("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx")
                .template(KubeNodePoolTemplateArgs.builder()
                    .metadata(KubeNodePoolTemplateMetadataArgs.builder()
                        .annotations(Map.ofEntries(
                            Map.entry("k1", "v1"),
                            Map.entry("k2", "v2")
                        ))
                        .finalizers()
                        .labels(Map.ofEntries(
                            Map.entry("k3", "v3"),
                            Map.entry("k4", "v4")
                        ))
                        .build())
                    .spec(KubeNodePoolTemplateSpecArgs.builder()
                        .taints(Map.ofEntries(
                            Map.entry("effect", "PreferNoSchedule"),
                            Map.entry("key", "k"),
                            Map.entry("value", "v")
                        ))
                        .unschedulable(false)
                        .build())
                    .build())
                .build());
    
        }
    }
    
    resources:
      pool:
        type: ovh:CloudProject:KubeNodePool
        properties:
          desiredNodes: 3
          flavorName: b2-7
          kubeId: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
          maxNodes: 3
          minNodes: 3
          serviceName: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
          template:
            metadata:
              annotations:
                k1: v1
                k2: v2
              finalizers: []
              labels:
                k3: v3
                k4: v4
            spec:
              taints:
                - effect: PreferNoSchedule
                  key: k
                  value: v
              unschedulable: false
    

    Create KubeNodePool Resource

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

    Constructor syntax

    new KubeNodePool(name: string, args: KubeNodePoolArgs, opts?: CustomResourceOptions);
    @overload
    def KubeNodePool(resource_name: str,
                     args: KubeNodePoolArgs,
                     opts: Optional[ResourceOptions] = None)
    
    @overload
    def KubeNodePool(resource_name: str,
                     opts: Optional[ResourceOptions] = None,
                     flavor_name: Optional[str] = None,
                     service_name: Optional[str] = None,
                     kube_id: Optional[str] = None,
                     autoscaling_scale_down_unready_time_seconds: Optional[int] = None,
                     autoscaling_scale_down_utilization_threshold: Optional[float] = None,
                     desired_nodes: Optional[int] = None,
                     anti_affinity: Optional[bool] = None,
                     autoscaling_scale_down_unneeded_time_seconds: Optional[int] = None,
                     max_nodes: Optional[int] = None,
                     min_nodes: Optional[int] = None,
                     monthly_billed: Optional[bool] = None,
                     name: Optional[str] = None,
                     autoscale: Optional[bool] = None,
                     template: Optional[_cloudproject.KubeNodePoolTemplateArgs] = None)
    func NewKubeNodePool(ctx *Context, name string, args KubeNodePoolArgs, opts ...ResourceOption) (*KubeNodePool, error)
    public KubeNodePool(string name, KubeNodePoolArgs args, CustomResourceOptions? opts = null)
    public KubeNodePool(String name, KubeNodePoolArgs args)
    public KubeNodePool(String name, KubeNodePoolArgs args, CustomResourceOptions options)
    
    type: ovh:CloudProject:KubeNodePool
    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 KubeNodePoolArgs
    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 KubeNodePoolArgs
    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 KubeNodePoolArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args KubeNodePoolArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args KubeNodePoolArgs
    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 kubeNodePoolResource = new Ovh.CloudProject.KubeNodePool("kubeNodePoolResource", new()
    {
        FlavorName = "string",
        ServiceName = "string",
        KubeId = "string",
        AutoscalingScaleDownUnreadyTimeSeconds = 0,
        AutoscalingScaleDownUtilizationThreshold = 0,
        DesiredNodes = 0,
        AntiAffinity = false,
        AutoscalingScaleDownUnneededTimeSeconds = 0,
        MaxNodes = 0,
        MinNodes = 0,
        MonthlyBilled = false,
        Name = "string",
        Autoscale = false,
        Template = new Ovh.CloudProject.Inputs.KubeNodePoolTemplateArgs
        {
            Metadata = new Ovh.CloudProject.Inputs.KubeNodePoolTemplateMetadataArgs
            {
                Annotations = 
                {
                    { "string", "string" },
                },
                Finalizers = new[]
                {
                    "string",
                },
                Labels = 
                {
                    { "string", "string" },
                },
            },
            Spec = new Ovh.CloudProject.Inputs.KubeNodePoolTemplateSpecArgs
            {
                Taints = new[]
                {
                    
                    {
                        { "string", "string" },
                    },
                },
                Unschedulable = false,
            },
        },
    });
    
    example, err := CloudProject.NewKubeNodePool(ctx, "kubeNodePoolResource", &CloudProject.KubeNodePoolArgs{
    	FlavorName:                               pulumi.String("string"),
    	ServiceName:                              pulumi.String("string"),
    	KubeId:                                   pulumi.String("string"),
    	AutoscalingScaleDownUnreadyTimeSeconds:   pulumi.Int(0),
    	AutoscalingScaleDownUtilizationThreshold: pulumi.Float64(0),
    	DesiredNodes:                             pulumi.Int(0),
    	AntiAffinity:                             pulumi.Bool(false),
    	AutoscalingScaleDownUnneededTimeSeconds:  pulumi.Int(0),
    	MaxNodes:                                 pulumi.Int(0),
    	MinNodes:                                 pulumi.Int(0),
    	MonthlyBilled:                            pulumi.Bool(false),
    	Name:                                     pulumi.String("string"),
    	Autoscale:                                pulumi.Bool(false),
    	Template: &cloudproject.KubeNodePoolTemplateArgs{
    		Metadata: &cloudproject.KubeNodePoolTemplateMetadataArgs{
    			Annotations: pulumi.StringMap{
    				"string": pulumi.String("string"),
    			},
    			Finalizers: pulumi.StringArray{
    				pulumi.String("string"),
    			},
    			Labels: pulumi.StringMap{
    				"string": pulumi.String("string"),
    			},
    		},
    		Spec: &cloudproject.KubeNodePoolTemplateSpecArgs{
    			Taints: pulumi.StringMapArray{
    				pulumi.StringMap{
    					"string": pulumi.String("string"),
    				},
    			},
    			Unschedulable: pulumi.Bool(false),
    		},
    	},
    })
    
    var kubeNodePoolResource = new KubeNodePool("kubeNodePoolResource", KubeNodePoolArgs.builder()
        .flavorName("string")
        .serviceName("string")
        .kubeId("string")
        .autoscalingScaleDownUnreadyTimeSeconds(0)
        .autoscalingScaleDownUtilizationThreshold(0)
        .desiredNodes(0)
        .antiAffinity(false)
        .autoscalingScaleDownUnneededTimeSeconds(0)
        .maxNodes(0)
        .minNodes(0)
        .monthlyBilled(false)
        .name("string")
        .autoscale(false)
        .template(KubeNodePoolTemplateArgs.builder()
            .metadata(KubeNodePoolTemplateMetadataArgs.builder()
                .annotations(Map.of("string", "string"))
                .finalizers("string")
                .labels(Map.of("string", "string"))
                .build())
            .spec(KubeNodePoolTemplateSpecArgs.builder()
                .taints(Map.of("string", "string"))
                .unschedulable(false)
                .build())
            .build())
        .build());
    
    kube_node_pool_resource = ovh.cloud_project.KubeNodePool("kubeNodePoolResource",
        flavor_name="string",
        service_name="string",
        kube_id="string",
        autoscaling_scale_down_unready_time_seconds=0,
        autoscaling_scale_down_utilization_threshold=0,
        desired_nodes=0,
        anti_affinity=False,
        autoscaling_scale_down_unneeded_time_seconds=0,
        max_nodes=0,
        min_nodes=0,
        monthly_billed=False,
        name="string",
        autoscale=False,
        template={
            "metadata": {
                "annotations": {
                    "string": "string",
                },
                "finalizers": ["string"],
                "labels": {
                    "string": "string",
                },
            },
            "spec": {
                "taints": [{
                    "string": "string",
                }],
                "unschedulable": False,
            },
        })
    
    const kubeNodePoolResource = new ovh.cloudproject.KubeNodePool("kubeNodePoolResource", {
        flavorName: "string",
        serviceName: "string",
        kubeId: "string",
        autoscalingScaleDownUnreadyTimeSeconds: 0,
        autoscalingScaleDownUtilizationThreshold: 0,
        desiredNodes: 0,
        antiAffinity: false,
        autoscalingScaleDownUnneededTimeSeconds: 0,
        maxNodes: 0,
        minNodes: 0,
        monthlyBilled: false,
        name: "string",
        autoscale: false,
        template: {
            metadata: {
                annotations: {
                    string: "string",
                },
                finalizers: ["string"],
                labels: {
                    string: "string",
                },
            },
            spec: {
                taints: [{
                    string: "string",
                }],
                unschedulable: false,
            },
        },
    });
    
    type: ovh:CloudProject:KubeNodePool
    properties:
        antiAffinity: false
        autoscale: false
        autoscalingScaleDownUnneededTimeSeconds: 0
        autoscalingScaleDownUnreadyTimeSeconds: 0
        autoscalingScaleDownUtilizationThreshold: 0
        desiredNodes: 0
        flavorName: string
        kubeId: string
        maxNodes: 0
        minNodes: 0
        monthlyBilled: false
        name: string
        serviceName: string
        template:
            metadata:
                annotations:
                    string: string
                finalizers:
                    - string
                labels:
                    string: string
            spec:
                taints:
                    - string: string
                unschedulable: false
    

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

    FlavorName string
    a valid OVHcloud public cloud flavor ID in which the nodes will be started. Ex: "b2-7". You can find the list of flavor IDs: https://www.ovhcloud.com/fr/public-cloud/prices/. Changing this value recreates the resource.
    KubeId string
    The id of the managed kubernetes cluster. Changing this value recreates the resource.
    ServiceName string
    The id of the public cloud project. If omitted, the OVH_CLOUD_PROJECT_SERVICE environment variable is used. Changing this value recreates the resource.
    AntiAffinity bool
    should the pool use the anti-affinity feature. Default to false. Changing this value recreates the resource.
    Autoscale bool
    Enable auto-scaling for the pool. Default to false.
    AutoscalingScaleDownUnneededTimeSeconds int
    scaleDownUnneededTimeSeconds autoscaling parameter How long a node should be unneeded before it is eligible for scale down
    AutoscalingScaleDownUnreadyTimeSeconds int
    scaleDownUnreadyTimeSeconds autoscaling parameter How long an unready node should be unneeded before it is eligible for scale down
    AutoscalingScaleDownUtilizationThreshold double
    scaleDownUtilizationThreshold autoscaling parameter Node utilization level, defined as sum of requested resources divided by capacity, below which a node can be considered for scale down

    • template - (Optional) Managed Kubernetes nodepool template, which is a complex object constituted by two main nested objects:
    DesiredNodes int
    number of nodes to start.
    MaxNodes int
    maximum number of nodes allowed in the pool. Setting desired_nodes over this value will raise an error.
    MinNodes int
    minimum number of nodes allowed in the pool. Setting desired_nodes under this value will raise an error.
    MonthlyBilled bool
    should the nodes be billed on a monthly basis. Default to false. Changing this value recreates the resource.
    Name string
    The name of the nodepool. Warning: _ char is not allowed! Changing this value recreates the resource.
    Template KubeNodePoolTemplate
    Node pool template
    FlavorName string
    a valid OVHcloud public cloud flavor ID in which the nodes will be started. Ex: "b2-7". You can find the list of flavor IDs: https://www.ovhcloud.com/fr/public-cloud/prices/. Changing this value recreates the resource.
    KubeId string
    The id of the managed kubernetes cluster. Changing this value recreates the resource.
    ServiceName string
    The id of the public cloud project. If omitted, the OVH_CLOUD_PROJECT_SERVICE environment variable is used. Changing this value recreates the resource.
    AntiAffinity bool
    should the pool use the anti-affinity feature. Default to false. Changing this value recreates the resource.
    Autoscale bool
    Enable auto-scaling for the pool. Default to false.
    AutoscalingScaleDownUnneededTimeSeconds int
    scaleDownUnneededTimeSeconds autoscaling parameter How long a node should be unneeded before it is eligible for scale down
    AutoscalingScaleDownUnreadyTimeSeconds int
    scaleDownUnreadyTimeSeconds autoscaling parameter How long an unready node should be unneeded before it is eligible for scale down
    AutoscalingScaleDownUtilizationThreshold float64
    scaleDownUtilizationThreshold autoscaling parameter Node utilization level, defined as sum of requested resources divided by capacity, below which a node can be considered for scale down

    • template - (Optional) Managed Kubernetes nodepool template, which is a complex object constituted by two main nested objects:
    DesiredNodes int
    number of nodes to start.
    MaxNodes int
    maximum number of nodes allowed in the pool. Setting desired_nodes over this value will raise an error.
    MinNodes int
    minimum number of nodes allowed in the pool. Setting desired_nodes under this value will raise an error.
    MonthlyBilled bool
    should the nodes be billed on a monthly basis. Default to false. Changing this value recreates the resource.
    Name string
    The name of the nodepool. Warning: _ char is not allowed! Changing this value recreates the resource.
    Template KubeNodePoolTemplateArgs
    Node pool template
    flavorName String
    a valid OVHcloud public cloud flavor ID in which the nodes will be started. Ex: "b2-7". You can find the list of flavor IDs: https://www.ovhcloud.com/fr/public-cloud/prices/. Changing this value recreates the resource.
    kubeId String
    The id of the managed kubernetes cluster. Changing this value recreates the resource.
    serviceName String
    The id of the public cloud project. If omitted, the OVH_CLOUD_PROJECT_SERVICE environment variable is used. Changing this value recreates the resource.
    antiAffinity Boolean
    should the pool use the anti-affinity feature. Default to false. Changing this value recreates the resource.
    autoscale Boolean
    Enable auto-scaling for the pool. Default to false.
    autoscalingScaleDownUnneededTimeSeconds Integer
    scaleDownUnneededTimeSeconds autoscaling parameter How long a node should be unneeded before it is eligible for scale down
    autoscalingScaleDownUnreadyTimeSeconds Integer
    scaleDownUnreadyTimeSeconds autoscaling parameter How long an unready node should be unneeded before it is eligible for scale down
    autoscalingScaleDownUtilizationThreshold Double
    scaleDownUtilizationThreshold autoscaling parameter Node utilization level, defined as sum of requested resources divided by capacity, below which a node can be considered for scale down

    • template - (Optional) Managed Kubernetes nodepool template, which is a complex object constituted by two main nested objects:
    desiredNodes Integer
    number of nodes to start.
    maxNodes Integer
    maximum number of nodes allowed in the pool. Setting desired_nodes over this value will raise an error.
    minNodes Integer
    minimum number of nodes allowed in the pool. Setting desired_nodes under this value will raise an error.
    monthlyBilled Boolean
    should the nodes be billed on a monthly basis. Default to false. Changing this value recreates the resource.
    name String
    The name of the nodepool. Warning: _ char is not allowed! Changing this value recreates the resource.
    template KubeNodePoolTemplate
    Node pool template
    flavorName string
    a valid OVHcloud public cloud flavor ID in which the nodes will be started. Ex: "b2-7". You can find the list of flavor IDs: https://www.ovhcloud.com/fr/public-cloud/prices/. Changing this value recreates the resource.
    kubeId string
    The id of the managed kubernetes cluster. Changing this value recreates the resource.
    serviceName string
    The id of the public cloud project. If omitted, the OVH_CLOUD_PROJECT_SERVICE environment variable is used. Changing this value recreates the resource.
    antiAffinity boolean
    should the pool use the anti-affinity feature. Default to false. Changing this value recreates the resource.
    autoscale boolean
    Enable auto-scaling for the pool. Default to false.
    autoscalingScaleDownUnneededTimeSeconds number
    scaleDownUnneededTimeSeconds autoscaling parameter How long a node should be unneeded before it is eligible for scale down
    autoscalingScaleDownUnreadyTimeSeconds number
    scaleDownUnreadyTimeSeconds autoscaling parameter How long an unready node should be unneeded before it is eligible for scale down
    autoscalingScaleDownUtilizationThreshold number
    scaleDownUtilizationThreshold autoscaling parameter Node utilization level, defined as sum of requested resources divided by capacity, below which a node can be considered for scale down

    • template - (Optional) Managed Kubernetes nodepool template, which is a complex object constituted by two main nested objects:
    desiredNodes number
    number of nodes to start.
    maxNodes number
    maximum number of nodes allowed in the pool. Setting desired_nodes over this value will raise an error.
    minNodes number
    minimum number of nodes allowed in the pool. Setting desired_nodes under this value will raise an error.
    monthlyBilled boolean
    should the nodes be billed on a monthly basis. Default to false. Changing this value recreates the resource.
    name string
    The name of the nodepool. Warning: _ char is not allowed! Changing this value recreates the resource.
    template KubeNodePoolTemplate
    Node pool template
    flavor_name str
    a valid OVHcloud public cloud flavor ID in which the nodes will be started. Ex: "b2-7". You can find the list of flavor IDs: https://www.ovhcloud.com/fr/public-cloud/prices/. Changing this value recreates the resource.
    kube_id str
    The id of the managed kubernetes cluster. Changing this value recreates the resource.
    service_name str
    The id of the public cloud project. If omitted, the OVH_CLOUD_PROJECT_SERVICE environment variable is used. Changing this value recreates the resource.
    anti_affinity bool
    should the pool use the anti-affinity feature. Default to false. Changing this value recreates the resource.
    autoscale bool
    Enable auto-scaling for the pool. Default to false.
    autoscaling_scale_down_unneeded_time_seconds int
    scaleDownUnneededTimeSeconds autoscaling parameter How long a node should be unneeded before it is eligible for scale down
    autoscaling_scale_down_unready_time_seconds int
    scaleDownUnreadyTimeSeconds autoscaling parameter How long an unready node should be unneeded before it is eligible for scale down
    autoscaling_scale_down_utilization_threshold float
    scaleDownUtilizationThreshold autoscaling parameter Node utilization level, defined as sum of requested resources divided by capacity, below which a node can be considered for scale down

    • template - (Optional) Managed Kubernetes nodepool template, which is a complex object constituted by two main nested objects:
    desired_nodes int
    number of nodes to start.
    max_nodes int
    maximum number of nodes allowed in the pool. Setting desired_nodes over this value will raise an error.
    min_nodes int
    minimum number of nodes allowed in the pool. Setting desired_nodes under this value will raise an error.
    monthly_billed bool
    should the nodes be billed on a monthly basis. Default to false. Changing this value recreates the resource.
    name str
    The name of the nodepool. Warning: _ char is not allowed! Changing this value recreates the resource.
    template cloudproject.KubeNodePoolTemplateArgs
    Node pool template
    flavorName String
    a valid OVHcloud public cloud flavor ID in which the nodes will be started. Ex: "b2-7". You can find the list of flavor IDs: https://www.ovhcloud.com/fr/public-cloud/prices/. Changing this value recreates the resource.
    kubeId String
    The id of the managed kubernetes cluster. Changing this value recreates the resource.
    serviceName String
    The id of the public cloud project. If omitted, the OVH_CLOUD_PROJECT_SERVICE environment variable is used. Changing this value recreates the resource.
    antiAffinity Boolean
    should the pool use the anti-affinity feature. Default to false. Changing this value recreates the resource.
    autoscale Boolean
    Enable auto-scaling for the pool. Default to false.
    autoscalingScaleDownUnneededTimeSeconds Number
    scaleDownUnneededTimeSeconds autoscaling parameter How long a node should be unneeded before it is eligible for scale down
    autoscalingScaleDownUnreadyTimeSeconds Number
    scaleDownUnreadyTimeSeconds autoscaling parameter How long an unready node should be unneeded before it is eligible for scale down
    autoscalingScaleDownUtilizationThreshold Number
    scaleDownUtilizationThreshold autoscaling parameter Node utilization level, defined as sum of requested resources divided by capacity, below which a node can be considered for scale down

    • template - (Optional) Managed Kubernetes nodepool template, which is a complex object constituted by two main nested objects:
    desiredNodes Number
    number of nodes to start.
    maxNodes Number
    maximum number of nodes allowed in the pool. Setting desired_nodes over this value will raise an error.
    minNodes Number
    minimum number of nodes allowed in the pool. Setting desired_nodes under this value will raise an error.
    monthlyBilled Boolean
    should the nodes be billed on a monthly basis. Default to false. Changing this value recreates the resource.
    name String
    The name of the nodepool. Warning: _ char is not allowed! Changing this value recreates the resource.
    template Property Map
    Node pool template

    Outputs

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

    AvailableNodes int
    Number of nodes which are actually ready in the pool
    CreatedAt string
    Creation date
    CurrentNodes int
    Number of nodes present in the pool
    Flavor string
    Flavor name
    Id string
    The provider-assigned unique ID for this managed resource.
    ProjectId string
    Project id
    SizeStatus string
    Status describing the state between number of nodes wanted and available ones
    Status string
    Current status
    UpToDateNodes int
    Number of nodes with the latest version installed in the pool
    UpdatedAt string
    Last update date
    AvailableNodes int
    Number of nodes which are actually ready in the pool
    CreatedAt string
    Creation date
    CurrentNodes int
    Number of nodes present in the pool
    Flavor string
    Flavor name
    Id string
    The provider-assigned unique ID for this managed resource.
    ProjectId string
    Project id
    SizeStatus string
    Status describing the state between number of nodes wanted and available ones
    Status string
    Current status
    UpToDateNodes int
    Number of nodes with the latest version installed in the pool
    UpdatedAt string
    Last update date
    availableNodes Integer
    Number of nodes which are actually ready in the pool
    createdAt String
    Creation date
    currentNodes Integer
    Number of nodes present in the pool
    flavor String
    Flavor name
    id String
    The provider-assigned unique ID for this managed resource.
    projectId String
    Project id
    sizeStatus String
    Status describing the state between number of nodes wanted and available ones
    status String
    Current status
    upToDateNodes Integer
    Number of nodes with the latest version installed in the pool
    updatedAt String
    Last update date
    availableNodes number
    Number of nodes which are actually ready in the pool
    createdAt string
    Creation date
    currentNodes number
    Number of nodes present in the pool
    flavor string
    Flavor name
    id string
    The provider-assigned unique ID for this managed resource.
    projectId string
    Project id
    sizeStatus string
    Status describing the state between number of nodes wanted and available ones
    status string
    Current status
    upToDateNodes number
    Number of nodes with the latest version installed in the pool
    updatedAt string
    Last update date
    available_nodes int
    Number of nodes which are actually ready in the pool
    created_at str
    Creation date
    current_nodes int
    Number of nodes present in the pool
    flavor str
    Flavor name
    id str
    The provider-assigned unique ID for this managed resource.
    project_id str
    Project id
    size_status str
    Status describing the state between number of nodes wanted and available ones
    status str
    Current status
    up_to_date_nodes int
    Number of nodes with the latest version installed in the pool
    updated_at str
    Last update date
    availableNodes Number
    Number of nodes which are actually ready in the pool
    createdAt String
    Creation date
    currentNodes Number
    Number of nodes present in the pool
    flavor String
    Flavor name
    id String
    The provider-assigned unique ID for this managed resource.
    projectId String
    Project id
    sizeStatus String
    Status describing the state between number of nodes wanted and available ones
    status String
    Current status
    upToDateNodes Number
    Number of nodes with the latest version installed in the pool
    updatedAt String
    Last update date

    Look up Existing KubeNodePool Resource

    Get an existing KubeNodePool 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?: KubeNodePoolState, opts?: CustomResourceOptions): KubeNodePool
    @staticmethod
    def get(resource_name: str,
            id: str,
            opts: Optional[ResourceOptions] = None,
            anti_affinity: Optional[bool] = None,
            autoscale: Optional[bool] = None,
            autoscaling_scale_down_unneeded_time_seconds: Optional[int] = None,
            autoscaling_scale_down_unready_time_seconds: Optional[int] = None,
            autoscaling_scale_down_utilization_threshold: Optional[float] = None,
            available_nodes: Optional[int] = None,
            created_at: Optional[str] = None,
            current_nodes: Optional[int] = None,
            desired_nodes: Optional[int] = None,
            flavor: Optional[str] = None,
            flavor_name: Optional[str] = None,
            kube_id: Optional[str] = None,
            max_nodes: Optional[int] = None,
            min_nodes: Optional[int] = None,
            monthly_billed: Optional[bool] = None,
            name: Optional[str] = None,
            project_id: Optional[str] = None,
            service_name: Optional[str] = None,
            size_status: Optional[str] = None,
            status: Optional[str] = None,
            template: Optional[_cloudproject.KubeNodePoolTemplateArgs] = None,
            up_to_date_nodes: Optional[int] = None,
            updated_at: Optional[str] = None) -> KubeNodePool
    func GetKubeNodePool(ctx *Context, name string, id IDInput, state *KubeNodePoolState, opts ...ResourceOption) (*KubeNodePool, error)
    public static KubeNodePool Get(string name, Input<string> id, KubeNodePoolState? state, CustomResourceOptions? opts = null)
    public static KubeNodePool get(String name, Output<String> id, KubeNodePoolState 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:
    AntiAffinity bool
    should the pool use the anti-affinity feature. Default to false. Changing this value recreates the resource.
    Autoscale bool
    Enable auto-scaling for the pool. Default to false.
    AutoscalingScaleDownUnneededTimeSeconds int
    scaleDownUnneededTimeSeconds autoscaling parameter How long a node should be unneeded before it is eligible for scale down
    AutoscalingScaleDownUnreadyTimeSeconds int
    scaleDownUnreadyTimeSeconds autoscaling parameter How long an unready node should be unneeded before it is eligible for scale down
    AutoscalingScaleDownUtilizationThreshold double
    scaleDownUtilizationThreshold autoscaling parameter Node utilization level, defined as sum of requested resources divided by capacity, below which a node can be considered for scale down

    • template - (Optional) Managed Kubernetes nodepool template, which is a complex object constituted by two main nested objects:
    AvailableNodes int
    Number of nodes which are actually ready in the pool
    CreatedAt string
    Creation date
    CurrentNodes int
    Number of nodes present in the pool
    DesiredNodes int
    number of nodes to start.
    Flavor string
    Flavor name
    FlavorName string
    a valid OVHcloud public cloud flavor ID in which the nodes will be started. Ex: "b2-7". You can find the list of flavor IDs: https://www.ovhcloud.com/fr/public-cloud/prices/. Changing this value recreates the resource.
    KubeId string
    The id of the managed kubernetes cluster. Changing this value recreates the resource.
    MaxNodes int
    maximum number of nodes allowed in the pool. Setting desired_nodes over this value will raise an error.
    MinNodes int
    minimum number of nodes allowed in the pool. Setting desired_nodes under this value will raise an error.
    MonthlyBilled bool
    should the nodes be billed on a monthly basis. Default to false. Changing this value recreates the resource.
    Name string
    The name of the nodepool. Warning: _ char is not allowed! Changing this value recreates the resource.
    ProjectId string
    Project id
    ServiceName string
    The id of the public cloud project. If omitted, the OVH_CLOUD_PROJECT_SERVICE environment variable is used. Changing this value recreates the resource.
    SizeStatus string
    Status describing the state between number of nodes wanted and available ones
    Status string
    Current status
    Template KubeNodePoolTemplate
    Node pool template
    UpToDateNodes int
    Number of nodes with the latest version installed in the pool
    UpdatedAt string
    Last update date
    AntiAffinity bool
    should the pool use the anti-affinity feature. Default to false. Changing this value recreates the resource.
    Autoscale bool
    Enable auto-scaling for the pool. Default to false.
    AutoscalingScaleDownUnneededTimeSeconds int
    scaleDownUnneededTimeSeconds autoscaling parameter How long a node should be unneeded before it is eligible for scale down
    AutoscalingScaleDownUnreadyTimeSeconds int
    scaleDownUnreadyTimeSeconds autoscaling parameter How long an unready node should be unneeded before it is eligible for scale down
    AutoscalingScaleDownUtilizationThreshold float64
    scaleDownUtilizationThreshold autoscaling parameter Node utilization level, defined as sum of requested resources divided by capacity, below which a node can be considered for scale down

    • template - (Optional) Managed Kubernetes nodepool template, which is a complex object constituted by two main nested objects:
    AvailableNodes int
    Number of nodes which are actually ready in the pool
    CreatedAt string
    Creation date
    CurrentNodes int
    Number of nodes present in the pool
    DesiredNodes int
    number of nodes to start.
    Flavor string
    Flavor name
    FlavorName string
    a valid OVHcloud public cloud flavor ID in which the nodes will be started. Ex: "b2-7". You can find the list of flavor IDs: https://www.ovhcloud.com/fr/public-cloud/prices/. Changing this value recreates the resource.
    KubeId string
    The id of the managed kubernetes cluster. Changing this value recreates the resource.
    MaxNodes int
    maximum number of nodes allowed in the pool. Setting desired_nodes over this value will raise an error.
    MinNodes int
    minimum number of nodes allowed in the pool. Setting desired_nodes under this value will raise an error.
    MonthlyBilled bool
    should the nodes be billed on a monthly basis. Default to false. Changing this value recreates the resource.
    Name string
    The name of the nodepool. Warning: _ char is not allowed! Changing this value recreates the resource.
    ProjectId string
    Project id
    ServiceName string
    The id of the public cloud project. If omitted, the OVH_CLOUD_PROJECT_SERVICE environment variable is used. Changing this value recreates the resource.
    SizeStatus string
    Status describing the state between number of nodes wanted and available ones
    Status string
    Current status
    Template KubeNodePoolTemplateArgs
    Node pool template
    UpToDateNodes int
    Number of nodes with the latest version installed in the pool
    UpdatedAt string
    Last update date
    antiAffinity Boolean
    should the pool use the anti-affinity feature. Default to false. Changing this value recreates the resource.
    autoscale Boolean
    Enable auto-scaling for the pool. Default to false.
    autoscalingScaleDownUnneededTimeSeconds Integer
    scaleDownUnneededTimeSeconds autoscaling parameter How long a node should be unneeded before it is eligible for scale down
    autoscalingScaleDownUnreadyTimeSeconds Integer
    scaleDownUnreadyTimeSeconds autoscaling parameter How long an unready node should be unneeded before it is eligible for scale down
    autoscalingScaleDownUtilizationThreshold Double
    scaleDownUtilizationThreshold autoscaling parameter Node utilization level, defined as sum of requested resources divided by capacity, below which a node can be considered for scale down

    • template - (Optional) Managed Kubernetes nodepool template, which is a complex object constituted by two main nested objects:
    availableNodes Integer
    Number of nodes which are actually ready in the pool
    createdAt String
    Creation date
    currentNodes Integer
    Number of nodes present in the pool
    desiredNodes Integer
    number of nodes to start.
    flavor String
    Flavor name
    flavorName String
    a valid OVHcloud public cloud flavor ID in which the nodes will be started. Ex: "b2-7". You can find the list of flavor IDs: https://www.ovhcloud.com/fr/public-cloud/prices/. Changing this value recreates the resource.
    kubeId String
    The id of the managed kubernetes cluster. Changing this value recreates the resource.
    maxNodes Integer
    maximum number of nodes allowed in the pool. Setting desired_nodes over this value will raise an error.
    minNodes Integer
    minimum number of nodes allowed in the pool. Setting desired_nodes under this value will raise an error.
    monthlyBilled Boolean
    should the nodes be billed on a monthly basis. Default to false. Changing this value recreates the resource.
    name String
    The name of the nodepool. Warning: _ char is not allowed! Changing this value recreates the resource.
    projectId String
    Project id
    serviceName String
    The id of the public cloud project. If omitted, the OVH_CLOUD_PROJECT_SERVICE environment variable is used. Changing this value recreates the resource.
    sizeStatus String
    Status describing the state between number of nodes wanted and available ones
    status String
    Current status
    template KubeNodePoolTemplate
    Node pool template
    upToDateNodes Integer
    Number of nodes with the latest version installed in the pool
    updatedAt String
    Last update date
    antiAffinity boolean
    should the pool use the anti-affinity feature. Default to false. Changing this value recreates the resource.
    autoscale boolean
    Enable auto-scaling for the pool. Default to false.
    autoscalingScaleDownUnneededTimeSeconds number
    scaleDownUnneededTimeSeconds autoscaling parameter How long a node should be unneeded before it is eligible for scale down
    autoscalingScaleDownUnreadyTimeSeconds number
    scaleDownUnreadyTimeSeconds autoscaling parameter How long an unready node should be unneeded before it is eligible for scale down
    autoscalingScaleDownUtilizationThreshold number
    scaleDownUtilizationThreshold autoscaling parameter Node utilization level, defined as sum of requested resources divided by capacity, below which a node can be considered for scale down

    • template - (Optional) Managed Kubernetes nodepool template, which is a complex object constituted by two main nested objects:
    availableNodes number
    Number of nodes which are actually ready in the pool
    createdAt string
    Creation date
    currentNodes number
    Number of nodes present in the pool
    desiredNodes number
    number of nodes to start.
    flavor string
    Flavor name
    flavorName string
    a valid OVHcloud public cloud flavor ID in which the nodes will be started. Ex: "b2-7". You can find the list of flavor IDs: https://www.ovhcloud.com/fr/public-cloud/prices/. Changing this value recreates the resource.
    kubeId string
    The id of the managed kubernetes cluster. Changing this value recreates the resource.
    maxNodes number
    maximum number of nodes allowed in the pool. Setting desired_nodes over this value will raise an error.
    minNodes number
    minimum number of nodes allowed in the pool. Setting desired_nodes under this value will raise an error.
    monthlyBilled boolean
    should the nodes be billed on a monthly basis. Default to false. Changing this value recreates the resource.
    name string
    The name of the nodepool. Warning: _ char is not allowed! Changing this value recreates the resource.
    projectId string
    Project id
    serviceName string
    The id of the public cloud project. If omitted, the OVH_CLOUD_PROJECT_SERVICE environment variable is used. Changing this value recreates the resource.
    sizeStatus string
    Status describing the state between number of nodes wanted and available ones
    status string
    Current status
    template KubeNodePoolTemplate
    Node pool template
    upToDateNodes number
    Number of nodes with the latest version installed in the pool
    updatedAt string
    Last update date
    anti_affinity bool
    should the pool use the anti-affinity feature. Default to false. Changing this value recreates the resource.
    autoscale bool
    Enable auto-scaling for the pool. Default to false.
    autoscaling_scale_down_unneeded_time_seconds int
    scaleDownUnneededTimeSeconds autoscaling parameter How long a node should be unneeded before it is eligible for scale down
    autoscaling_scale_down_unready_time_seconds int
    scaleDownUnreadyTimeSeconds autoscaling parameter How long an unready node should be unneeded before it is eligible for scale down
    autoscaling_scale_down_utilization_threshold float
    scaleDownUtilizationThreshold autoscaling parameter Node utilization level, defined as sum of requested resources divided by capacity, below which a node can be considered for scale down

    • template - (Optional) Managed Kubernetes nodepool template, which is a complex object constituted by two main nested objects:
    available_nodes int
    Number of nodes which are actually ready in the pool
    created_at str
    Creation date
    current_nodes int
    Number of nodes present in the pool
    desired_nodes int
    number of nodes to start.
    flavor str
    Flavor name
    flavor_name str
    a valid OVHcloud public cloud flavor ID in which the nodes will be started. Ex: "b2-7". You can find the list of flavor IDs: https://www.ovhcloud.com/fr/public-cloud/prices/. Changing this value recreates the resource.
    kube_id str
    The id of the managed kubernetes cluster. Changing this value recreates the resource.
    max_nodes int
    maximum number of nodes allowed in the pool. Setting desired_nodes over this value will raise an error.
    min_nodes int
    minimum number of nodes allowed in the pool. Setting desired_nodes under this value will raise an error.
    monthly_billed bool
    should the nodes be billed on a monthly basis. Default to false. Changing this value recreates the resource.
    name str
    The name of the nodepool. Warning: _ char is not allowed! Changing this value recreates the resource.
    project_id str
    Project id
    service_name str
    The id of the public cloud project. If omitted, the OVH_CLOUD_PROJECT_SERVICE environment variable is used. Changing this value recreates the resource.
    size_status str
    Status describing the state between number of nodes wanted and available ones
    status str
    Current status
    template cloudproject.KubeNodePoolTemplateArgs
    Node pool template
    up_to_date_nodes int
    Number of nodes with the latest version installed in the pool
    updated_at str
    Last update date
    antiAffinity Boolean
    should the pool use the anti-affinity feature. Default to false. Changing this value recreates the resource.
    autoscale Boolean
    Enable auto-scaling for the pool. Default to false.
    autoscalingScaleDownUnneededTimeSeconds Number
    scaleDownUnneededTimeSeconds autoscaling parameter How long a node should be unneeded before it is eligible for scale down
    autoscalingScaleDownUnreadyTimeSeconds Number
    scaleDownUnreadyTimeSeconds autoscaling parameter How long an unready node should be unneeded before it is eligible for scale down
    autoscalingScaleDownUtilizationThreshold Number
    scaleDownUtilizationThreshold autoscaling parameter Node utilization level, defined as sum of requested resources divided by capacity, below which a node can be considered for scale down

    • template - (Optional) Managed Kubernetes nodepool template, which is a complex object constituted by two main nested objects:
    availableNodes Number
    Number of nodes which are actually ready in the pool
    createdAt String
    Creation date
    currentNodes Number
    Number of nodes present in the pool
    desiredNodes Number
    number of nodes to start.
    flavor String
    Flavor name
    flavorName String
    a valid OVHcloud public cloud flavor ID in which the nodes will be started. Ex: "b2-7". You can find the list of flavor IDs: https://www.ovhcloud.com/fr/public-cloud/prices/. Changing this value recreates the resource.
    kubeId String
    The id of the managed kubernetes cluster. Changing this value recreates the resource.
    maxNodes Number
    maximum number of nodes allowed in the pool. Setting desired_nodes over this value will raise an error.
    minNodes Number
    minimum number of nodes allowed in the pool. Setting desired_nodes under this value will raise an error.
    monthlyBilled Boolean
    should the nodes be billed on a monthly basis. Default to false. Changing this value recreates the resource.
    name String
    The name of the nodepool. Warning: _ char is not allowed! Changing this value recreates the resource.
    projectId String
    Project id
    serviceName String
    The id of the public cloud project. If omitted, the OVH_CLOUD_PROJECT_SERVICE environment variable is used. Changing this value recreates the resource.
    sizeStatus String
    Status describing the state between number of nodes wanted and available ones
    status String
    Current status
    template Property Map
    Node pool template
    upToDateNodes Number
    Number of nodes with the latest version installed in the pool
    updatedAt String
    Last update date

    Supporting Types

    KubeNodePoolTemplate, KubeNodePoolTemplateArgs

    KubeNodePoolTemplateMetadata, KubeNodePoolTemplateMetadataArgs

    Annotations Dictionary<string, string>
    annotations
    Finalizers List<string>
    finalizers
    Labels Dictionary<string, string>
    labels
    Annotations map[string]string
    annotations
    Finalizers []string
    finalizers
    Labels map[string]string
    labels
    annotations Map<String,String>
    annotations
    finalizers List<String>
    finalizers
    labels Map<String,String>
    labels
    annotations {[key: string]: string}
    annotations
    finalizers string[]
    finalizers
    labels {[key: string]: string}
    labels
    annotations Mapping[str, str]
    annotations
    finalizers Sequence[str]
    finalizers
    labels Mapping[str, str]
    labels
    annotations Map<String>
    annotations
    finalizers List<String>
    finalizers
    labels Map<String>
    labels

    KubeNodePoolTemplateSpec, KubeNodePoolTemplateSpecArgs

    Taints List<ImmutableDictionary<string, string>>
    taints
    Unschedulable bool
    unschedulable
    Taints []map[string]string
    taints
    Unschedulable bool
    unschedulable
    taints List<Map<String,String>>
    taints
    unschedulable Boolean
    unschedulable
    taints {[key: string]: string}[]
    taints
    unschedulable boolean
    unschedulable
    taints Sequence[Mapping[str, str]]
    taints
    unschedulable bool
    unschedulable
    taints List<Map<String>>
    taints
    unschedulable Boolean
    unschedulable

    Import

    OVHcloud Managed Kubernetes Service cluster node pool can be imported using the service_name, the id of the cluster, and the id of the nodepool separated by “/” E.g.,

    bash

    $ pulumi import ovh:CloudProject/kubeNodePool:KubeNodePool pool service_name/kube_id/poolid
    

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

    Package Details

    Repository
    ovh ovh/pulumi-ovh
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the ovh Terraform Provider.
    ovh logo
    OVHCloud v1.1.0 published on Thursday, Nov 21, 2024 by OVHcloud