Kubernetes
5 min de lecture •

vcluster : plusieurs équipes sur un seul cluster Kubernetes

Un cluster managé par équipe coûte cher, un namespace ne suffit plus dès qu'il y a des CRDs. vcluster donne un control plane par équipe sur des nœuds partagés.

Arthur Zinck
Arthur Zinck
Expert DevOps Kubernetes & Cloud

Un namespace, ça va, jusqu’au jour où ça ne va plus

La demande revient souvent. Quatre, cinq, huit équipes sur la même plateforme, et chacune veut son Kubernetes. Pas par caprice : l’équipe data a besoin d’un opérateur qui installe ses CRDs, l’équipe plateforme teste une version d’API qui n’est pas encore celle de la prod, et l’équipe qui fait du machine learning voudrait bien un admission controller à elle.

La réponse par défaut, c’est un namespace par équipe. Ça marche très bien tant qu’on parle de pods, de services et de secrets. Ça casse dès qu’on sort du namespace. Une CRD est un objet cluster-scoped : installée par l’équipe data, elle est visible par tout le monde, dans la version choisie par l’équipe data. Un ClusterRole, pareil. Un webhook qui intercepte les créations de pods, pareil, et là ce n’est plus de la cohabitation, c’est une équipe qui peut casser les déploiements des autres sans le vouloir.

L’autre réponse par défaut, c’est un cluster managé par équipe. Chez AWS, le control plane EKS est facturé 0,10 $ de l’heure, soit environ 73 $ par mois et par cluster. Huit équipes, ça fait 584 $ par mois avant d’avoir démarré le moindre nœud. Et ce n’est pas la partie chère.

La partie chère, c’est ce qu’il y a dans chaque cluster. Un ingress controller, cert-manager, external-dns, les agents de métriques et de logs, l’opérateur PostgreSQL, l’agent ArgoCD. Ce socle tourne huit fois, avec ses requests, sur des nœuds qu’on paie huit fois. Sur des clusters d’équipe qui passent leurs nuits et leurs week-ends à ne rien faire, on finit par payer plus cher le socle que les applications.

Ce que vcluster déplace

vcluster fait tenir un cluster Kubernetes dans un namespace d’un autre cluster. Concrètement, on déploie un StatefulSet qui contient un API server, un controller-manager et un magasin de données. C’est un vrai control plane, avec sa propre base d’objets. L’équipe reçoit un kubeconfig, elle fait kubectl get ns, elle voit ses namespaces à elle et rien d’autre.

Ce qui n’est pas dupliqué, c’est le scheduler et les nœuds. Un composant, le syncer, surveille les objets du cluster virtuel et recopie dans le namespace hôte tout ce qui doit réellement tourner : les pods, et avec eux les secrets, configmaps, services et volumes dont ils dépendent. Les noms sont réécrits au passage — un pod api du namespace default d’un vcluster team-a devient api-x-default-x-team-a côté hôte. Les nœuds font le chemin inverse : le cluster virtuel voit des objets Node en lecture, dérivés de ceux de l’hôte.

Résultat : les CRDs, les ClusterRoles, les webhooks et les versions d’API sont propres à chaque équipe, parce qu’ils vivent dans un API server distinct. Mais les pods s’exécutent sur la même flotte de nœuds, avec le même autoscaler et le même bin packing. C’est exactement le partage qu’on cherchait.

La mise en place

Un chart Helm, un fichier de values, un namespace.

# vcluster.yaml
controlPlane:
  distro:
    k8s:
      enabled: true
  backingStore:
    etcd:
      deploy:
        enabled: true
sync:
  toHost:
    ingresses:
      enabled: true
  fromHost:
    nodes:
      enabled: true
helm upgrade --install team-a vcluster \
  --repo https://charts.loft.sh \
  --namespace team-a --create-namespace \
  --values vcluster.yaml

Deux minutes plus tard, le control plane est prêt et l’équipe s’y connecte comme sur n’importe quel cluster.

Le distro k8s avec etcd, c’est le choix que je fais quand le vcluster est censé durer. Le mode par défaut, plus léger, stocke les objets dans du SQLite sur un volume : parfait pour un environnement jetable, moins rassurant pour un cluster d’équipe qui vit six mois. Le surcoût, c’est un pod etcd par équipe. On le paie sans discuter.

sync.toHost.ingresses mérite qu’on s’y arrête. Sans lui, les Ingress créés dans le vcluster restent des objets morts dans un API server que personne d’autre ne lit : aucun ingress controller ne les voit. Avec lui, ils sont recopiés côté hôte, et le Traefik du cluster, cert-manager et external-dns font leur travail habituel. Une seule installation de ce socle, mutualisée entre toutes les équipes. C’est le même raisonnement que pour les environnements éphémères par Pull Request : le contrôleur est cher à maintenir, l’objet qu’il traite ne l’est pas.

Côté garde-fous, rien de nouveau à inventer. Le namespace hôte porte un ResourceQuota et une LimitRange, et comme tous les pods de l’équipe atterrissent dedans, le plafond s’applique quoi que fasse l’équipe dans son cluster virtuel. C’est un des effets secondaires les plus agréables du modèle : on garde les outils de quota qu’on connaît déjà.

Ce qui n’est pas isolé

Il faut le dire clairement, parce que le mot « cluster » laisse croire à une frontière qui n’existe pas.

Le kernel est partagé. Les pods de toutes les équipes tournent sur les mêmes nœuds, avec le même noyau. Une évasion de conteneur ne s’arrête pas à la limite du vcluster. Si le modèle de menace inclut du code hostile, il faut un runtime isolé — gVisor, Kata — ou de vraies machines séparées.

Le réseau est plat par défaut. Le syncer recopie les pods dans un namespace hôte, mais rien n’empêche un pod de l’équipe A de joindre une IP de pod de l’équipe B. C’est une NetworkPolicy par namespace hôte qui ferme la porte, et il faut l’écrire.

Le stockage suit les StorageClasses de l’hôte, partagées elles aussi. Et l’API server de l’hôte reste un point commun : une équipe qui sature les nœuds sature les nœuds de tout le monde. Le quota est là pour ça, à condition de le poser.

Quand un vrai cluster reste la bonne réponse

Quand l’isolation est une exigence de conformité et pas une commodité d’organisation. Quand un tenant a besoin de ses propres nœuds, de son propre CNI ou d’une autre version de Kubernetes que celle de l’hôte. Quand la panne du cluster hôte ne doit pas emporter le tenant avec elle — un vcluster ne survit pas à la mort de son hôte, et c’est la limite structurelle du modèle.

Pour tout le reste, c’est-à-dire des équipes internes qui se font raisonnablement confiance mais qui ne veulent pas se marcher dessus, vcluster donne 90 % de ce qu’apporte un cluster dédié pour le prix d’un namespace bien tenu.


Si vous êtes en train d’arbitrer entre un cluster par équipe et un namespace par équipe, il y a une troisième option, et elle est souvent la bonne. Contactez-moi si vous voulez en parler.

Points clés à retenir

  • ✓ Un namespace ne suffit plus dès qu'une équipe a besoin de ses propres CRDs, ClusterRoles ou versions d'API
  • ✓ vcluster met un control plane complet dans un namespace : API server isolé, nœuds mutualisés
  • ✓ Le vrai gain n'est pas le control plane managé économisé, c'est le socle (ingress, cert-manager, agents) installé une fois au lieu de N
  • ✓ Ce qui n'est pas isolé : le kernel, le réseau sans NetworkPolicy, le stockage
  • ✓ Un vcluster ne survit pas à la panne de son hôte — pour de la conformité ou des nœuds dédiés, il faut un vrai cluster

Cet article t'a plu ?

Je publie régulièrement mes retours d'expérience infra, Kubernetes et FinOps sur LinkedIn. Abonne-toi pour les suivre. Mes MP sont ouverts, tu peux m'écrire direct.

kubernetes vcluster multi-tenant platform-engineering helm finops rbac crd

Partager cet article

Twitter LinkedIn

Articles similaires

Diagnostic gratuit

Ce problème,
c'est chez toi ?

Diagnostic gratuit — 30 min

30 minutes en visio. Tu repars avec 2 ou 3 pistes chiffrées, même si on ne travaille pas ensemble.