---
title: "How to manage nodes and node pools on an OVHcloud Managed Kubernetes cluster"
description: "Depending on your preferred workflow, you can manage them through:"
url: https://docs.us.ovhcloud.com/en/public-cloud/managed-kubernetes/managing-nodes
lang: en
---
> For AI agents: the complete documentation index is available at https://docs.us.ovhcloud.com/en/llms.txt, the full documentation bundle is available at https://docs.us.ovhcloud.com/en/llms-full.txt.

# How to manage nodes and node pools on an OVHcloud Managed Kubernetes cluster

Depending on your preferred workflow, you can manage them through:

- The [OVHcloud Control Panel](https://manager.us.ovhcloud.com/).
- The [OVHcloud API](https://api.us.ovhcloud.com/).
- The `NodePools` Custom Resource Definition (CRD) via `kubectl`.

We will walk you through each method to help you efficiently scale and manage your Kubernetes infrastructure.

 

## Requirements

- You have an [OVHcloud Managed Kubernetes cluster](https://docs.us.ovhcloud.com/en/public-cloud/managed-kubernetes/create-cluster.md)
- If you plan to manage node pools using the `NodePools` CRD, make sure you have the [kubectl](https://kubernetes.io/docs/reference/kubectl/overview/) command-line tool installed.

**Note:**

You can find [detailed installation instructions](https://kubernetes.io/docs/tasks/tools/install-kubectl/) on the official Kubernetes website

 

### On nodes and node pools

#### Via the OVHcloud Control Panel

In your OVHcloud Managed Kubernetes cluster, nodes are grouped into node pools (groups of nodes sharing the same configuration).
When you order a new cluster, it is created with a default node pool. Refer to our guide on [creating a cluster](https://docs.us.ovhcloud.com/en/public-cloud/managed-kubernetes/create-cluster.md) for more information.
In this guide, we explain how to do some basic operations with nodes and node pools using the Public Cloud section of the [OVHcloud Control Panel](https://manager.us.ovhcloud.com/).

#### Via the OVHcloud API

In your OVHcloud Managed Kubernetes cluster, nodes are grouped into node pools (groups of nodes sharing the same configuration).
In the cluster creation call, you can specify the specs of the first node pool that will be created with it. Then, you can update this node pool or add additional node pools of different sizes and types.
Upon creation, a node pool is defined by its name (`name`), the type of instance within our available catalog (`flavorName`), the number of identical nodes that you want in that node pool (`desiredNodes`), and potentially self-defined boundaries to limit the value of desired nodes (`minNodes` and `maxNodes`).
You can also enable the `autoscale` feature, and the `desiredNodes` will be automatically updated at runtime within the `minNodes` and `maxNodes` boundaries, depending on the resource reservations of your workload (see [Using the cluster autoscaler](https://docs.us.ovhcloud.com/en/public-cloud/managed-kubernetes/using-cluster-autoscaler.md)).
Setting the `antiAffinity` boolean ensures that nodes in that node pool will be created on different hypervisors (bare metal machines), ensuring the best availability for your workload. The maximum number of nodes is set to 5 if this feature is activated on a node pool (you can create multiple node pools, each with 5 anti-affinity nodes max).
Setting the `template` property will allow you to define some specs (annotations, finalizers, labels, taints, and schedulability) that will be applied to each node under this node pool.
You can enable the creation of Floating IPS with the `attachFloatingIps` parameter. If the `enabled` boolean is true, a Floating IP will be attached to each node.
Finally, the boolean `monthlyBilled` ensures that all nodes in a node pool will be spawned in monthly billing mode and therefore benefit from the monthly discount.
After creation, the `desiredNodes`, `minNodes`, `maxNodes`, `autoscale`, and `template` properties can also be edited at any time.
In this guide, we explain how to do some basic operations with nodes and node pools using the [OVHcloud API](https://api.us.ovhcloud.com/): adding nodes to an existing node pool, creating a new node pool, etc.

#### Via the NodePools CRD

In your OVHcloud Managed Kubernetes cluster, nodes are grouped into node pools (groups of nodes sharing the same configuration).
When you create your cluster, it's created with a default node pool. Then, you can modify the size of this node pool or add additional node pools of different sizes and types.
In this guide, we explain how to do some basic operations with nodes and node pools using the `NodePools` CRD: adding nodes to an existing node pool, creating a new node pool, etc.

 

## Instructions

### Accessing your cluster

#### Via the OVHcloud Control Panel

Access our administration UI for your OVHcloud Managed Kubernetes clusters by clicking on `Managed Kubernetes Service` in the left-hand menu in the Public Cloud section of the [OVHcloud Control Panel](https://manager.us.ovhcloud.com/). In the table, select a cluster by clicking on the cluster name.
In this administration UI, you have several tabs:
- **Service**: Here, you will have a global view of your cluster with important information like the status, the API URL, or the `kubectl` configuration file.
- **Node pools**: Here you will find the active node pools of your cluster. You will be able to add, resize, or remove node pools.
- **APIServer access**: You can add IPv4 ranges to restrict access to your cluster’s APIServer.
- **Logs**: Here you will find the logs for your Kubernetes cluster’s control plane.

#### Via the OVHcloud API

From the [OVHcloud API](https://api.us.ovhcloud.com/), click the `Authentication` button and log in to your account through SSO.
Choose the `/cloud` section, which you can filter with the term `kube`, to see all of the [Kubernetes-related API calls](https://api.us.ovhcloud.com/console/?section=%2Fcloud\&branch=v1#get-/cloud/project/-serviceName-/kube).

#### Via the NodePools CRD

Kubernetes [Custom Resources](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/) are extensions of the Kubernetes API. Like the default Kubernetes resources, the Custom Resources are endpoints in the Kubernetes API that store collections of API objects of a certain kind. Custom Resources allows you to easily extend Kubernetes by adding new features and behaviors.
The simplest way to add a Custom Resource to Kubernetes is to define a [`CustomResourceDefinition` (CRD)](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/#customresourcedefinitions) with the resource schema.
One of our targets in developing the node pools for OVHcloud Managed Kubernetes was to give our users the capability to fully manage node pools (and by extension nodes themselves) from within Kubernetes, so the logical way to do it was to propose them as Custom Resources in your Kubernetes cluster, by developing the `NodePools` CRD.
To verify that the `NodePools` CRD is available in your cluster, do:
```
kubectl get crd
```
You get the list of installed CRDs and, inside it, the `nodepools.kube.cloud.ovh.us`
```
kubectl get crd
NAME                                             CREATED AT
...
ingresses.networking.internal.knative.dev              2023-01-03T07:25:05Z
ipamblocks.crd.projectcalico.org                       2022-09-22T07:00:52Z
ipamconfigs.crd.projectcalico.org                      2022-09-22T07:00:52Z
ipamhandles.crd.projectcalico.org                      2022-09-22T07:00:53Z
ippools.crd.projectcalico.org                          2022-09-22T07:00:53Z
ipreservations.crd.projectcalico.org                   2022-09-22T07:00:53Z
kubecontrollersconfigurations.crd.projectcalico.org    2022-09-22T07:00:53Z
metrics.autoscaling.internal.knative.dev               2023-01-03T07:25:05Z
networkpolicies.crd.projectcalico.org                  2022-09-22T07:00:53Z
networksets.crd.projectcalico.org                      2022-09-22T07:00:53Z
nodefeaturerules.nfd.k8s-sigs.io                       2023-04-25T07:59:58Z
nodefeatures.nfd.k8s-sigs.io                           2023-04-25T07:59:58Z
nodepools.kube.cloud.ovh.us                            2022-09-22T06:59:43Z
podautoscalers.autoscaling.internal.knative.dev        2023-01-03T07:25:05Z
podmonitors.monitoring.coreos.com                      2023-04-26T09:19:12Z
podvolumebackups.velero.io                             2022-10-04T06:56:54Z
podvolumerestores.velero.io                            2022-10-04T06:56:54Z
probes.monitoring.coreos.com                           2023-04-26T09:19:12Z
...
```
You can get the details of the `NodePools` CRD by doing:
```
kubectl describe crd nodepools.kube.cloud.ovh.us
```
The most interesting part is the spec of the CRD, describing the `NodePool` object and its properties:
```
spec:
  description: NodePoolSpec defines the desired state of NodePool
  properties:
    antiAffinity:
      type: boolean
      description: If true, all nodes present in the pool will be spawned on different hosts (or hypervisors).
    autoscale:
      type: boolean
      description: Represents whether the pool should be autoscaled.
    autoscaling:
      description:  Represents the autoscaling customization of a node pool.
      nullable:     true
      properties:
        scaleDownUnneededTimeSeconds:
          description:  Represents how long a node should be unneeded before it is eligible for scale down.
          format:       int32
          minimum:      0
          nullable:     true
          type:         integer
        scaleDownUnreadyTimeSeconds:
          description:  Represents how long an unready node should be unneeded before it is eligible for scale down.
          format:       int32
          minimum:      0
          nullable:     true
          type:         integer
        scaleDownUtilizationThreshold:
          description:  Represents the ratio of used resources (CPU & RAM) over allocatable resources below which a node is eligible for scale down Kubebuilder does not handle float, this must be a string.
          nullable:     true
          type:         string
      type:             object
    desiredNodes:
      description: Represents number of nodes wanted in the pool.
      format: int32
      maximum: 100
      minimum: 0
      type: integer
    flavor:
      description: Represents the flavor nodes wanted in the pool.
      type: string
    maxNodes:
      description: Represents the maximum number of nodes which should be
        present in the pool.
      format: int32
      maximum: 100
      minimum: 0
      type: integer
    minNodes:
      description: Represents the minimum number of nodes which should be
        present in the pool.
      format: int32
      maximum: 100
      minimum: 0
      type: integer
    monthlyBilled:
      type: boolean
      description: If true, all nodes present in the pool will be billed each month (not hourly).
  required:
  - desiredNodes
  - flavor
  type: object
```
After creation:
- The `desiredNodes` can be edited, and the node pool will automatically be resized to accommodate this new value.
- `minNodes`, `maxNodes`, `autoscale`, and `autoscaling` can also be edited at any time.
- `flavor`, `name`, and `antiAffinity` are not editable.

Be aware that `maxNodes` is set by default to 5 when `antiAffinity` is enabled.
To configure cluster autoscaling based on node pools, follow the documentation [Configuring the cluster autoscaler](https://docs.us.ovhcloud.com/en/public-cloud/managed-kubernetes/configure-cluster-autoscaler.md) and [Cluster autoscaler example](https://docs.us.ovhcloud.com/en/public-cloud/managed-kubernetes/cluster-autoscaler-example.md). To customers developing their own autoscaling scripts, we strongly encourage you to define `minNodes` and `maxNodes`.

 

### Getting your cluster information

#### Via the OVHcloud Control Panel

Go to your Public Cloud project in the OVHcloud Control Panel and click on the `Managed Kubernetes Service` section. Click the name of your cluster.

#### Via the OVHcloud API

Get the IDs of your clusters:

[GET /cloud/project/{serviceName}/kube](https://api.us.ovhcloud.com/console/?section=/cloud&branch=v1#get-/cloud/project/-serviceName-/kube)

To list the details of a particular cluster:

[GET /cloud/project/{serviceName}/kube/{kubeId}](https://api.us.ovhcloud.com/console/?section=/cloud&branch=v1#get-/cloud/project/-serviceName-/kube/-kubeId-)

 

### Listing node pools

#### Via the OVHcloud Control Panel

Go to your Public Cloud project in the OVHcloud Control Panel and click on the `Managed Kubernetes Service`, then click on the name of the relevant cluster.
On the following screen, choose the `Node pools` tab.

#### Via the OVHcloud API

List your Public Cloud projects:

[GET /cloud/project](https://api.us.ovhcloud.com/console/?section=/cloud&branch=v1#get-/cloud/project)

List your OVHcloud Managed Kubernetes clusters:

[GET /cloud/project/{serviceName}/kube](https://api.us.ovhcloud.com/console/?section=/cloud&branch=v1#get-/cloud/project/-serviceName-/kube)

List the node pools in a cluster:

[GET /cloud/project/{serviceName}/kube/{kubeId}/nodepool](https://api.us.ovhcloud.com/console/?section=/cloud&branch=v1#get-/cloud/project/-serviceName-/kube/-kubeId-/nodepool)

#### Via the NodePools CRD

To list node pools, you can use:
```
kubectl get nodepools
```
In this case, we have one node pool in the cluster, called `my-node-pool`, with 2 B2-7 nodes:
```
kubectl get nodepools
NAME            FLAVOR   MONTHLY BILLED   ANTI AFFINITY   DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   MIN   MAX   AGE
nodepool-b2-7   b2-7     true             true            2         2         2            2           0     5     14d
```
You can see the state of the node pool, how many nodes you want in the pool (`DESIRED`), how many actually are (`CURRENT`), how many of them are up-to-date (`UP-TO-DATE`), and how many are available to be used (`AVAILABLE`).

 

### Getting node pool details

#### Via the OVHcloud Control Panel

Go to your Public Cloud project in the OVHcloud Control Panel and click on the `Managed Kubernetes Service`, then click on the name of the relevant cluster.
On the following screen, choose the `Node pools` tab and select the name of your pool.

#### Via the OVHcloud API

List the details of a node pool in a cluster:

[GET /cloud/project/{serviceName}/kube/{kubeId}/nodepool](https://api.us.ovhcloud.com/console/?section=/cloud&branch=v1#get-/cloud/project/-serviceName-/kube/-kubeId-/nodepool)

#### Via the NodePools CRD

Use this command:
```
kubectl get nodepool <nodepool-name> -o yaml
```

 

### Creating a node pool

#### Via the OVHcloud Control Panel

In the _Node pools_ tab, click on the button `Add a node pool`.

Fill the fields to create a new node pool.

**Warning:** **NOTE:** The **name of node pool** should be in lowercase. The “\_” and “.” characters are not allowed. The node pool name cannot begin with a number.

The subsequent node pool configuration steps are described in [Creating a cluster](https://docs.us.ovhcloud.com/en/public-cloud/managed-kubernetes/create-cluster.md).

**Note:** To learn more about the flavors of the current OVHcloud range, [refer to this page](https://us.ovhcloud.com/public-cloud/).

#### Via the OVHcloud API

To create a node pool:

**Note:** You will need to give it a `flavorName` parameter, with the flavor of the instance you want to create. For this tutorial, choose a general purpose node, like the `b2-7` flavor.
If you want your node pool to have at least one node, set the `desiredNodes` to a value above 0.

[POST /cloud/project/{serviceName}/kube/{kubeId}/nodepool](https://api.us.ovhcloud.com/console/?section=/cloud&branch=v1#post-/cloud/project/-serviceName-/kube/-kubeId-/nodepool)

#### Via the NodePools CRD

To create a new node pool, you simply need to create a new node pool manifest.
Copy the next YAML manifest in a `new-nodepool.yaml` file:
```
apiVersion: kube.cloud.ovh.com/v1alpha1
kind: NodePool
metadata:
  name: my-new-node-pool
spec:
  antiAffinity: false
  autoscale: false
  autoscaling:
    scaleDownUnneededTimeSeconds: 600
    scaleDownUnreadyTimeSeconds: 1200
    scaleDownUtilizationThreshold: "0.5"
  desiredNodes: 3
  flavor: b2-7
  maxNodes: 100
  minNodes: 0
  monthlyBilled: false
```

**Note:**
`antiAffinity`, `flavor`, and `name` fields will not be editable after creation. You cannot change the `monthlyBilled` field from true to false.

Then apply it to your cluster:
```
kubectl apply -f new-nodepool.yaml
```
Your new node pool will be created:
```
kubectl apply -f new-nodepool.yaml
nodepool.kube.cloud.ovh.us/my-new-node-pool created

$ kubectl get nodepools
NAME               FLAVOR   AUTOSCALED   MONTHLY BILLED   ANTIAFFINITY   DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   MIN   MAX   AGE
my-new-node-pool   b2-7     false        false            false          3                                            0     100   3s
nodepool-b2-7      b2-7     false        true             true           2         2         2            2           0     5     14d
```
At the beginning, the new node pool is empty, but if you wait a few seconds, you will see how the nodes are progressively created and made available (one after another).
```
kubectl get nodepools
NAME               FLAVOR   AUTOSCALED   MONTHLY BILLED   ANTIAFFINITY   DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   MIN   MAX   AGE
my-new-node-pool   b2-7     false        false            false          3         3         3                        0     100   3s
nodepool-b2-7      b2-7     false        true             true           2         2         2            2           0     5     14d
```

 

### Updating a node pool

#### Via the OVHcloud Control Panel

#### Configuring a node pool

To access the nodes' configuration, switch to the _Node pools_ tab. Click on the _more options_ `...` button in the row of the node pool concerned, then select `See nodes`.

Here you can delete a node by clicking on the _more options_ `...` button to the right of the node.

 
#### Adding nodes to an existing node pool

In the _Node pools_ tab, click on the _more options_ `...` button in the row of the node pool concerned, then select `Configure node pool size`.

In the pop-up window, you can resize your node pool by adding nodes. Alternatively, you can enable the autoscaling feature, which allows you to set the minimum and maximum pool size instead.

##### Via the OVHcloud API

To upsize or downsize your node pool and set the `desiredNodes` to the new pool size:

**Note:** You can also modify some other properties, through it is not possible to update/change the following parameters: `antiAffinity`, `flavorName` and `name`.

[PUT /cloud/project/{serviceName}/kube/{kubeId}/nodepool/{nodePoolId}](https://api.us.ovhcloud.com/console/?section=/cloud&branch=v1#put-/cloud/project/-serviceName-/kube/-kubeId-/nodepool/-nodePoolId-)

```
{
  "antiAffinity": false,
  "autoscale": false,
  "desiredNodes": 4,
  "flavorName": "b2-7",
  "monthlyBilled": false,
  "name": "my-node-pool"
}
```

##### Via the NodePools CRD

To upsize or downsize your node pool, you can simply edit the YAML file and reapply it.
For example, raise the `desiredNodes` to 5 in `new-nodepool.yaml` and apply the file:
```
kubectl apply -f new-nodepool.yaml
nodepool.kube.cloud.ovh.com/my-new-node-pool configured
```

**Note:**
`antiaffinity`, `flavor` and `name` fields can't be edited.

```
kubectl get nodepools
NAME               FLAVOR   AUTOSCALED   MONTHLY BILLED   ANTIAFFINITY   DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   MIN   MAX   AGE
my-new-node-pool   b2-7     false        false            false          5         3         3                        0     100   3s
nodepool-b2-7      b2-7     false        true             true           2         2         2            2           0     5     14d
```
The `DESIRED` number of nodes has changed, and the two additional nodes will be created.
Then, after a few minutes:
```
kubectl get nodepools
NAME               FLAVOR   AUTOSCALED   MONTHLY BILLED   ANTIAFFINITY   DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   MIN   MAX   AGE
my-new-node-pool   b2-7     false        false            false          5         5         5            3           0     100   3s
nodepool-b2-7      b2-7     false        true             true           2         2         2            2           0     5     14d

$ kubectl get nodepools
NAME               FLAVOR   AUTOSCALED   MONTHLY BILLED   ANTIAFFINITY   DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   MIN   MAX   AGE
my-new-node-pool   b2-7     false        false            false          5         5         5            5           0     100   3s
nodepool-b2-7      b2-7     false        true             true           2         2         2            2           0     5     14d
```
You can also use `kubectl scale —replicas=X` to change the number of desired nodes. For example, let's resize it back to 2 nodes:
```
kubectl scale --replicas=2 nodepool my-new-node-pool
```
```
kubectl scale --replicas=2 nodepool my-new-node-pool
nodepool.kube.cloud.ovh.com/my-new-node-pool scaled

$ kubectl get nodepools
NAME               FLAVOR   AUTOSCALED   MONTHLY BILLED   ANTIAFFINITY   DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   MIN   MAX   AGE
my-new-node-pool   b2-7     false        false            false          2         5         5            5           0     100   3s
nodepool-b2-7      b2-7     false        true             true           2         2         2            2           0     5     14d
```
Then, after a few minutes:
```
kubectl get nodepools
NAME               FLAVOR   AUTOSCALED   MONTHLY BILLED   ANTIAFFINITY   DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   MIN   MAX   AGE
my-new-node-pool   b2-7     false        false            false          2         2         2            2           0     100   3s
nodepool-b2-7      b2-7     false        true             true           2         2         2            2           0     5     14d
```

 

### Deleting a node pool

#### Via the OVHcloud Control Panel

In the _Node pools_ tab, click the _more options_ `...` button in the row of the node pool concerned, then select `Delete pool`.

Confirm the decision by typing `DELETE` into the field. Then, click the `Delete` button.

#### Via the OVHcloud API

To delete a node pool:

[DELETE /cloud/project/{serviceName}/kube/{kubeId}/nodepool/{nodePoolId}](https://api.us.ovhcloud.com/console/?section=/cloud&branch=v1#delete-/cloud/project/-serviceName-/kube/-kubeId-/nodepool/-nodePoolId-)

#### Via the NodePools CRD

You can simply use `kubectl` to delete a node pool, as any other Kubernetes resource:
```
kubectl delete nodepool my-new-node-pool
```
After executing this command, Kubernetes will change the state of the nodes to `Ready,SchedulingDisabled`. After a little time, Nodes will be deleted.

 

## Go further

To have an overview of the OVHcloud Managed Kubernetes service, visit the [OVHcloud Managed Kubernetes page](https://us.ovhcloud.com/public-cloud/kubernetes/).

To deploy your first application on your Kubernetes cluster, we invite you to follow our guides to [configure default settings for `kubectl`](https://docs.us.ovhcloud.com/en/public-cloud/managed-kubernetes/configure-kubectl.md) and to [deploy a Hello World application](https://docs.us.ovhcloud.com/en/public-cloud/managed-kubernetes/deploying-node-pool.md).

Browse all the [Managed Kubernetes Service (MKS) guides](https://docs.us.ovhcloud.com/en/public-cloud/managed-kubernetes/landing-page-managed-kubernetes.md).

Browse the rest of the [OVHcloud US documentation](https://docs.us.ovhcloud.com/en/index.md) for guides on our other products and services.

Learn more about [Managed Kubernetes](https://us.ovhcloud.com/public-cloud/kubernetes/) on the OVHcloud US website.

If you need training or technical assistance to implement our solutions, contact your sales representative or click on [this link](https://us.ovhcloud.com/professional-services/) to get a quote and ask our Professional Services experts for a custom analysis of your project.
