Gérer les nœuds et les pools de nœuds d'un cluster OVHcloud Managed Kubernetes

Dans votre cluster OVHcloud Managed Kubernetes, les nœuds sont regroupés en pools de nœuds (des groupes de nœuds partageant la même configuration).

Dans l'appel de création du cluster, vous pouvez spécifier les caractéristiques d'un premier pool de nœuds qui sera créé avec celui-ci. Vous pouvez ensuite modifier ce pool de nœuds, ou ajouter d'autres pools de nœuds de tailles et de types différents.

À sa création, un pool de nœuds est défini par son nom (name), le type d'instance choisi dans notre catalogue (flavorName), le nombre de nœuds identiques que vous souhaitez y placer (desiredNodes) et, éventuellement, des bornes que vous définissez pour encadrer la valeur de desiredNodes (minNodes et maxNodes).

Vous pouvez également activer la fonctionnalité autoscale : la valeur desiredNodes sera alors mise à jour automatiquement pendant l'exécution, dans les limites de minNodes et maxNodes, en fonction des réservations de ressources de votre workload (consultez le guide « Utiliser le cluster autoscaler »).

Le booléen antiAffinity garantit que les nœuds de ce pool de nœuds seront créés sur des hyperviseurs (machines physiques) différents, assurant ainsi la meilleure disponibilité possible pour votre workload. Le nombre maximal de nœuds est fixé à 5 lorsque cette fonctionnalité est activée sur un pool de nœuds (vous pouvez bien entendu créer plusieurs pools de nœuds comportant chacun 5 nœuds en anti-affinité au maximum).

La propriété template vous permet de définir certaines caractéristiques (annotations, finalizers, labels, taints, ordonnançabilité) qui seront appliquées à chaque nœud de ce pool de nœuds.

Si votre cluster a été créé dans une région 3AZ, vous devez également spécifier une AZ à l'aide du paramètre availabilityZones.

Vous pouvez activer la création de Floating IP avec le paramètre attachFloatingIps. Si le booléen enabled est défini sur true, une Floating IP sera attachée à chaque nœud.

Enfin, le booléen monthlyBilled garantit que tous les nœuds d'un pool de nœuds seront créés en mode de facturation mensuelle et bénéficieront donc de la remise mensuelle.

Après la création, les propriétés desiredNodes, minNodes, maxNodes, autoscale et template peuvent également être modifiées à tout moment.

Ce guide explique comment effectuer quelques opérations de base sur les nœuds et les pools de nœuds via l'API OVHcloud : ajouter des nœuds à un pool de nœuds existant, créer un nouveau pool de nœuds, etc.

Dans votre cluster OVHcloud Managed Kubernetes, les nœuds sont regroupés en pools de nœuds (des groupes de nœuds partageant la même configuration).

Lorsque vous créez votre cluster, celui-ci est créé avec un pool de nœuds par défaut. Vous pouvez ensuite modifier la taille de ce pool de nœuds, ou ajouter d'autres pools de nœuds de tailles et de types différents.

Ce guide explique comment effectuer quelques opérations de base sur les nœuds et les pools de nœuds à l'aide de la CRD NodePools : ajouter des nœuds à un pool de nœuds existant, créer un nouveau pool de nœuds, etc.

Par souci de simplicité, nous utilisons l'API Explorer, qui permet d'explorer l'API, de l'appréhender et d'interagir avec elle de manière interactive.

Si vous accédez à la section Cloud de l'API Explorer, vous y verrez l'endpoint /cloud/project/{serviceName}/kube disponible.

Les Custom Resources Kubernetes sont des extensions de l'API Kubernetes. Comme les ressources Kubernetes par défaut, les Custom Resources sont des endpoints de l'API Kubernetes qui stockent des collections d'objets d'API d'un type donné. Les Custom Resources permettent d'étendre facilement Kubernetes en y ajoutant de nouvelles fonctionnalités et de nouveaux comportements.

La manière la plus simple d'ajouter une Custom Resource à Kubernetes consiste à définir une CustomResourceDefinition (CRD) accompagnée du schéma de la ressource.

L'un de nos objectifs lors du développement des pools de nœuds pour OVHcloud Managed Kubernetes était de permettre à nos utilisateurs de gérer intégralement leurs pools de nœuds (et par extension les nœuds eux-mêmes) depuis Kubernetes. La solution logique consistait donc à les proposer sous forme de Custom Resources dans votre cluster Kubernetes, en développant la CRD NodePools.

Pour vérifier que la CRD NodePools est disponible dans votre cluster, exécutez :

kubectl get crd

Vous obtenez la liste des CRD installées, dans laquelle figure nodepools.kube.cloud.ovh.com :

$ 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
<b style={{color:"yellow"}}>nodepools.kube.cloud.ovh.com                           2022-09-22T06:59:43Z</b>
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
...

Vous pouvez obtenir le détail de la CRD NodePools en exécutant :

kubectl describe crd nodepools.kube.cloud.ovh.com

La partie la plus intéressante est la spécification de la CRD, qui décrit l'objet NodePool et ses propriétés :

spec:
  description: NodePoolSpec defines the desired state of NodePool
  properties:
    antiAffinity:
      description: Represents whether the pool should deploy instances exclusively on different hypervisors.
      nullable: true
      type: boolean
    attachFloatingIPs:
      description: AttachFloatingIPs describe network exposition of all nodes in the pool.
      nullable: true
      properties:
        enabled:
          description: Enabled describe the node network exposition. If True, a FloatingIP will be assigned to each node.
          type: boolean
      type: object
    autoscale:
      description: Represents whether the pool should be autoscaled.
      nullable: true
      type: boolean
    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
    availabilityZones:
      description: Represents the availability zones of the node pool.
      items:
        type: string
      nullable: true
      type: array
    desiredNodes:
      description: Represents the number of nodes wanted in the pool.
      format: int32
      maximum: 999
      minimum: 0
      type: integer
    flavor:
      description: Represents the node flavors wanted in the pool.
      type: string
    maxNodes:
      description: Represents the maximum number of nodes which should be
        present in the pool.
      format: int32
      maximum: 999
      minimum: 0
      nullable: true
      type: integer
    minNodes:
      description: Represents the minimum number of nodes which should be
        present in the pool.
      format: int32
      maximum: 100
      minimum: 0
      nullable: true
      type: integer
    monthlyBilled:
      description: Represents the billing type of the pool. False means that the pool is hourly-billed.
      nullable: true
      type: boolean
    template:
      description: Template describes the configuration of the nodes in the pool. On change, it will be applied to existing and future nodes.
      nullable: true
      properties:
        metadata:
          description: Standard object's metadata.
          properties:
            annotations:
              additionalProperties:
                type: string
              description: 'Annotations is an unstructured key value map
                stored with a resource that may be set by external tools
                to store and retrieve arbitrary metadata. They are not queryable
                and should be preserved when modifying objects. More info:
                http://kubernetes.io/docs/user-guide/annotations'
              type: object
            finalizers:
              description: Must be empty before the object is deleted from
                the registry. Each entry is an identifier for the responsible
                component that will remove the entry from the list. If the
                deletionTimestamp of the object is non-nil, entries in this
                list can only be removed.
              items:
                type: string
              type: array
            labels:
              additionalProperties:
                type: string
              description: 'Map of string keys and values that can be used
                to organize and categorize (scope and select) objects. May
                match selectors of replication controllers and services.
                More info: http://kubernetes.io/docs/user-guide/labels'
              type: object
          required:
          - annotations
          - finalizers
          - labels
          type: object
        spec:
          description: Specification of the desired behavior of the node.
          properties:
            taints:
              description: If specified, the node's taints.
              items:
                description: The node this Taint is attached to has the "effect" on any pod that does not tolerate the Taint.
                properties:
                  effect:
                    description: Required. The effect of the taint on pods
                      that do not tolerate the taint. Valid effects are
                      NoSchedule, PreferNoSchedule and NoExecute.
                    type: string
                  key:
                    description: Required. The taint key to be applied to a node.
                    type: string
                  timeAdded:
                    description: TimeAdded represents the time at which the taint was added. It is only written for NoExecute taints.
                    format: date-time
                    type: string
                  value:
                    description: The taint value corresponding to the taint
                      key.
                    type: string
                required:
                - effect
                - key
                type: object
              type: array
            unschedulable:
              description: 'Unschedulable controls node schedulability of
                new pods. By default, node is schedulable. More info: https://kubernetes.io/docs/concepts/nodes/node/#manual-node-administration'
              type: boolean
          required:
          - taints
          - unschedulable
          type: object
      required:
      - metadata
      - spec
      type: object
  required:
  - flavor
 type: object

Après la création :

• La valeur desiredNodes peut être modifiée : le pool de nœuds sera automatiquement redimensionné pour s'adapter à cette nouvelle valeur.
• minNodes, maxNodes, autoscale et autoscaling peuvent également être modifiés à tout moment.
• /!\ flavor, name et antiAffinity ne sont pas modifiables.

Notez que maxNodes est fixé par défaut à 5 lorsque antiAffinity est activé.

Pour configurer l'autoscaling du cluster à partir des pools de nœuds, suivez les guides « Configurer le cluster autoscaler » et « Exemple de cluster autoscaler ».
Si vous développez vos propres scripts d'autoscaling, nous vous recommandons vivement de définir minNodes et maxNodes.

L'endpoint d'API GET /cloud/project/{serviceName}/kube/{kubeId} fournit des informations importantes sur votre cluster OVHcloud Managed Kubernetes, notamment son statut et son URL.

Résultat :

{
  "id": "xxxxxxxx-xxxx-4cdf-xxxx-xxxxxxxxxxxx",
  "region": "GRA5",
  "name": "my_kube_cluster",
  "url": "xxxxxx.c1.gra.k8s.ovh.net",
  "nodesUrl": "xxxxxx.nodes.c1.gra.k8s.ovh.net",
  "version": "1.34.1",
  "nextUpgradeVersions": [],
  "kubeProxyMode": "iptables",
  "customization": {
    "apiServer": {
      "admissionPlugins": {
        "enabled": [
          "NodeRestriction"
        ],
        "disabled": [
          "AlwaysPullImages"
        ]
      }
    },
    "kubeProxy": {
      "iptables": {},
      "ipvs": {}
    }
  },
  "status": "READY",
  "updatePolicy": "ALWAYS_UPDATE",
  "isUpToDate": true,
  "controlPlaneIsUpToDate": true,
  "privateNetworkId": null,
  "createdAt": "2023-02-09T10:41:13Z",
  "updatedAt": "2023-02-09T10:45:06Z"
}

L'endpoint d'API GET /cloud/project liste tous les services Public Cloud disponibles associés à votre compte OVHcloud :

Résultat :

[
  "a212xxxxxxxxxxxxxxxxx59"
]

Choisissez le service Public Cloud correspondant à votre OVHcloud Managed Kubernetes. Dans cet exemple, nous le désignerons par serviceName.

L'endpoint d'API GET /cloud/project/{serviceName}/kube liste tous les clusters disponibles dans le projet choisi :

Résultat :

[
  "xxxxxxxx-xxxx-4cdf-xxxx-xxxxxxxxxxxx",
  "xxxxxxxx-xxxx-43f6-xxxx-xxxxxxxxxxxx",
  "xxxxxxxx-xxxx-4217-xxxx-xxxxxxxxxxxx",
  "xxxxxxxx-xxxx-458b-xxxx-xxxxxxxxxxxx",
  "xxxxxxxx-xxxx-4845-xxxx-xxxxxxxxxxxx"
]

En l'appelant, vous obtenez la liste des identifiants de vos clusters Kubernetes. Notez l'identifiant du cluster que vous souhaitez utiliser. Dans cet exemple, nous le désignerons par kubeId.

Pour lister les pools de nœuds, vous pouvez utiliser :

kubectl get nodepools

Dans notre cas, le cluster comporte un seul pool de nœuds, nommé my-node-pool, avec 2 nœuds B2-7 :

$ kubectl get nodepools
NAME            FLAVOR   AUTOSCALED   MONTHLY BILLED   ANTIAFFINITY   DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   MIN   MAX   AGE
nodepool-b2-7   b2-7     false        true             true           2         2         2            2           0     5     14d

Vous pouvez y voir l'état du pool de nœuds, le nombre de nœuds souhaités dans le pool (DESIRED), le nombre de nœuds réellement présents (CURRENT), combien d'entre eux sont à jour (UP-TO-DATE) et combien sont disponibles (AVAILABLE).

Utilisez l'endpoint d'API GET /cloud/project/{serviceName}/kube/{kubeId}/nodepool/{nodePoolId} pour obtenir des informations sur un pool de nœuds précis :

Résultat :

{
  "id": "xxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxx",
  "projectId": "xxxx",
  "name": "nodepool-xxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxx",
  "flavor": "b2-7",
  "status": "READY",
  "sizeStatus": "CAPACITY_OK",
  "autoscale": false,
  "monthlyBilled": false,
  "antiAffinity": false,
  "desiredNodes": 1,
  "minNodes": 0,
  "maxNodes": 100,
  "currentNodes": 1,
  "availableNodes": 1,
  "upToDateNodes": 0,
  "createdAt": "2022-09-22T06:58:09Z",
  "updatedAt": "2022-12-15T15:14:33Z",
  "autoscaling": {
    "scaleDownUtilizationThreshold": 0.5,
    "scaleDownUnneededTimeSeconds": 600,
    "scaleDownUnreadyTimeSeconds": 1200
  },
  "template": {
    "metadata": {
      "labels": {},
      "annotations": {},
      "finalizers": []
    },
    "spec": {
      "unschedulable": false,
      "taints": []
    }
  }
}

Utilisez cette commande :

kubectl get nodepool <nodepool-name> -o yaml

Utilisez l'endpoint d'API POST /cloud/project/{serviceName}/kube/{kubeId}/nodepool pour créer un nouveau pool de nœuds :

Requête :

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

Vous devrez lui fournir un paramètre flavorName, correspondant à la flavor de l'instance que vous souhaitez créer. Pour ce tutoriel, choisissez un nœud à usage générique, comme la flavor b2-7.

Si vous souhaitez que votre pool de nœuds comporte au moins un nœud, définissez desiredNodes sur une valeur supérieure à 0.

Dans une région 3AZ, le paramètre availabilityZones est également obligatoire. Pour connaître les availabilityZones disponibles dans une région, vous pouvez utiliser l'endpoint d'API GET /cloud/project/{serviceName}/capabilities/productAvailability .

Pour augmenter ou réduire la taille de votre pool de nœuds, vous pouvez utiliser l'endpoint d'API PUT /cloud/project/{serviceName}/kube/{kubeId}/nodepool/{nodePoolId} et définir desiredNodes sur la nouvelle taille du pool. Vous pouvez également modifier d'autres propriétés :

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

Pour augmenter ou réduire la taille de votre pool de nœuds, il vous suffit de modifier le fichier YAML et de l'appliquer à nouveau.
Par exemple, portez desiredNodes à 5 dans new-nodepool.yaml et appliquez le fichier :

$ kubectl apply -f new-nodepool.yaml
nodepool.kube.cloud.ovh.com/my-new-node-pool configured

$ 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

Le nombre de nœuds DESIRED a changé, et les deux nœuds supplémentaires vont être créés.

Puis, après quelques 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

Vous pouvez également utiliser kubectl scale —replicas=X pour modifier le nombre de nœuds souhaités. Par exemple, pour le redimensionner à 2 nœuds :

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

Puis, après quelques 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

Pour supprimer un pool de nœuds, utilisez l'endpoint d'API DELETE /cloud/project/{serviceName}/kube/{kubeId}/nodepool/{nodePoolId} :

Vous pouvez simplement utiliser kubectl pour supprimer un pool de nœuds, comme pour toute autre ressource Kubernetes :

kubectl delete nodepool my-new-node-pool

Après l'exécution de cette commande, Kubernetes fera passer l'état des nœuds à Ready,SchedulingDisabled. Au bout d'un moment, les nœuds seront supprimés.