Kappsul est une plateforme que nous avons construite à l'Université de Lorraine : depuis une interface web, n'importe quel étudiant peut obtenir un environnement privé et isolé sur un cluster Kubernetes partagé, et y déployer ses propres applications. C'est l'histoire du jour où nous avons changé la façon dont ces environnements sont gérés — une migration qui a tourné au vert du début à la fin, et qui a supprimé tous les workspaces créés après les deux cents premiers, avec tout leur contenu.
C'est aussi une histoire qui finit bien, et la fin a un nom : Velero.
Si vous avez lu Workspaces Kubernetes multi-tenant : isolation, self-heal et une seule config, vous connaissez la destination de cette migration et les raisons de ce choix. Cet article raconte la partie de l'histoire que cet article-là ignore volontairement : le jour de la bascule, et les deux heures pendant lesquelles tout a mal tourné. Il est écrit pour être lu seul.
Ce qu'est Kappsul, et pourquoi l'isolation est le produit
Les universités ont un problème Kubernetes bien particulier. Les cours et les projets d'étudiants ont besoin d'un endroit où faire tourner une application — une app web, une API, une base de données — mais on ne peut pas donner un cluster à chaque étudiant, et on ne peut pas donner à des utilisateurs non fiables un accès à un cluster partagé. La plateforme fait donc quelque chose d'intermédiaire : l'étudiant clique sur un bouton, et obtient un namespace sur le cluster partagé, avec tout ce qu'il faut pour travailler en sécurité à l'intérieur.
Cela a l'air trivial. C'est tout le produit. La partie difficile n'est pas de créer un
namespace — kubectl create namespace est une commande. La partie difficile, c'est le
contrat :
Un namespace privé avec une frontière étanche, et assez de liberté à l'intérieur pour être utile.
« Assez de liberté » veut dire que l'étudiant est admin dans son namespace : il peut
déployer avec Helm, écrire des manifests, exposer des services, gérer ses propres
secrets. « Frontière étanche » veut dire qu'aucune de ces libertés ne peut fuiter — vers
les autres étudiants, ou vers la plateforme elle-même. Concrètement, chaque workspace
est une enveloppe de primitives Kubernetes :
| Couche | Ce que l'étudiant obtient | Ce dont la plateforme est protégée |
|---|---|---|
| Namespace | Un endroit privé pour déployer | Collisions de noms, accès inter-tenant |
| ResourceQuota | Un budget CPU/mémoire/stockage prévisible | Un workspace qui affame tout le cluster |
| LimitRange | Des requests et limits par défaut | Les pods sans limits qui passent au travers |
| RBAC | admin dans son namespace, et rien d'autre | Les étudiants qui agissent hors de leur workspace |
| NetworkPolicy | Default-deny, ingress/egress explicites | Le trafic inter-namespace, l'egress inattendu |
| Pod Security Admission | baseline en enforcement | Les pods privilégiés ou dangereux |
Un dernier point compte pour cette histoire : les tenants sont des étudiants. Ils apprennent Kubernetes. Ils vont supprimer des choses, modifier des choses, casser des choses — parfois exprès, juste pour voir. La plateforme ne peut pas empêcher chaque erreur à l'intérieur du workspace ; elle doit remettre le workspace en état quand ça arrive. Gardez cela en tête : c'est pour ça que le self-heal était une exigence, et c'est ainsi qu'un outil de suppression s'est retrouvé avec une arme chargée.
L'époque ArgoCD : un bon outil, bien utilisé
Pendant la première année, le cycle de vie de chaque workspace était géré par ArgoCD.
Créer un workspace signifiait créer une Application ArgoCD — une par workspace —
pointant vers un dépôt Git contenant un petit chart Helm : l'enveloppe du tableau
ci-dessus. ArgoCD surveillait Git, rendait le chart, et appliquait les ressources dans le
namespace de l'étudiant. Modifier le chart dans Git, et tous les workspaces convergeaient
vers le nouvel état.
Je veux être juste avec cette conception, parce qu'elle était bonne :
- Déclarative et auditable. L'état souhaité de chaque workspace vivait dans Git.
- Self-heal gratuit. Tout le métier d'ArgoCD est de détecter la dérive et de la corriger — un étudiant modifie le quota, ArgoCD le remet. Nous avions notre exigence la plus dure grâce à un outil que nous n'avions pas à écrire.
- Éprouvé. Réconciliation, retries, sémantique de sync : des problèmes résolus, pas les nôtres.
- Zéro code de contrôleur maison. Rien à maintenir, rien à débugger à 2 h du matin.
Alors pourquoi partir ? Quatre raisons, par ordre d'importance croissante :
- Il était sur le chemin critique. Créer un workspace — l'opération la plus élémentaire du produit — exigeait qu'ArgoCD et GitLab soient up. Dès que l'un des deux avait une panne, les étudiants ne pouvaient plus obtenir de workspace du tout. Une dépendance qui n'avait rien à voir avec le produit pouvait faire tomber le produit.
- Il tuait la portabilité. La plateforme ne pouvait pas tourner sur un cluster sans ArgoCD ni serveur Git. Nous voulions que Kappsul tourne sur n'importe quel cluster Kubernetes.
- C'était du sur-mesure à l'envers. Nous utilisions une plateforme de delivery complète pour réconcilier six ressources par tenant. Pas de dashboard de sync par workspace, pas d'app-of-apps, pas de multi-cluster — rien de tout cela n'aurait jamais servi.
- Un décalage d'échelle. Des milliers de minuscules Applications, rafraîchies à l'infini par le contrôleur ArgoCD, pour au final un namespace avec quatre objets de politique dedans.
La destination : un CRD, un opérateur, deux comportements
Le remplacement est volontairement petit. Une ressource personnalisée Workspace est le
registre du tenant — qui la possède, quel namespace, quels invités. Un petit opérateur
observe ces CRs et fait exactement deux choses, qui se révèlent être les seules choses
dont nous avons jamais eu besoin dans la boîte à outils GitOps :
- Self-heal : si un étudiant modifie une ressource qui appartient à la plateforme,
on la remet — détecté non pas en comparant des hash, mais en demandant à
managedFieldsqui a fait la dernière écriture ; - Propagation : l'enveloppe est définie une seule fois, dans un template ConfigMap géré dans Git ; on le change une fois, et l'opérateur le propage à tous les workspaces.
Le GitOps reste pour le delivery — le template vit dans Git et arrive dans le cluster par l'outil de votre choix. Le runtime n'a besoin de rien d'autre que l'API Kubernetes et le CRD. C'est tout l'argument : GitOps pour le delivery, un opérateur pour le runtime — et c'est traité en profondeur dans l'article sur l'opérateur.
Ce que ce diagramme ne montre pas, c'est la partie qui compte pour la suite de cette histoire : la suppression. Quand un Workspace CR est supprimé, l'opérateur supprime le namespace de l'étudiant — propagation foreground, finalizer maintenu jusqu'à ce que le namespace ait disparu. L'opérateur possède désormais le cycle de vie du namespace. Gardez cela en tête aussi.
Le plan : un job de migration
Donc : plusieurs milliers de workspaces actifs, chacun actuellement une Application ArgoCD, devaient devenir des Workspace CRs. Sans interruption de service, sans perte de données, sans « on réparera en chemin ». L'opérateur était prêt ; la bascule était le problème.
Deux propriétés de l'ancien monde ont façonné toute la conception, et il faut les deux pour comprendre la panne :
Fait 1 — le finalizer de cascade. Les finalizers Kubernetes sont des chaînes posées
sur un objet qui signifient « ne me supprime vraiment que lorsque le contrôleur qui
possède cette chaîne le dit ». Chaque Application de workspace portait
resources-finalizer.argocd.argoproj.io, qui est la promesse d'ArgoCD : quand cette
Application est supprimée, supprime tout ce qu'elle a créé — le quota, le RBAC, les
network policies, et le namespace lui-même. Supprimer un namespace supprime tout son
contenu : chaque Deployment, Service, ConfigMap, Secret des étudiants, et chaque PVC avec
ses données. Ce finalizer est la raison pour laquelle la migration ne pouvait pas se
contenter de supprimer les Applications en priant.
Fait 2 — les Applications étaient vivantes. Le contrôleur d'applications d'ArgoCD
rafraîchit chaque Application à son cycle de reconciliation, en réécrivant les champs de
status à chaque passe. Chacune de ces écritures incrémente le resourceVersion de
l'objet — le jeton de concurrence que Kubernetes utilise pour rejeter les écritures
basées sur des données périmées.
La logique du job de migration, par Application :
- Convertir l'Application ArgoCD en
WorkspaceCR (même nom, même namespace cible, utilisateur et invités extraits des Helm values) ; - Créer le Workspace CR et attendre que l'opérateur le réconcilie — polling
jusqu'à ce que le workspace passe
Activeavec toutes les ressources de l'enveloppe créées ; - Retirer le finalizer de cascade de l'Application, pour que sa suppression ne supprime que l'objet Application ;
- Supprimer l'Application ArgoCD.
Les déploiements, services et volumes des étudiants n'ont jamais été du ressort d'ArgoCD — ils étaient installés par notre application service via Helm, directement dans le namespace. Sur le papier, la passation était propre : l'opérateur reprend l'enveloppe, et les affaires de l'étudiant n'ont jamais été à supprimer par ArgoCD.
Et le job lui-même était réellement soigné. Il traitait les Applications par lots avec des pauses entre les lots, limitait le débit de ses appels API, suivait sa progression dans un fichier sur un volume persistant pour pouvoir reprendre, supportait un mode dry-run, et refusait de supprimer une Application avant que son Workspace CR soit totalement réconcilié. Nous en étions fiers. Ce n'est pas de l'ironie — chacune de ces décisions était bonne. Le bug était ailleurs.
La répétition
Nous avons d'abord testé le job en préprod. La préprod avait une poignée de workspaces.
Le run a pris quelques minutes. Chaque Application a été convertie, chaque Workspace CR réconcilié presque instantanément, chaque finalizer retiré, chaque Application supprimée. Nous avons comparé les namespaces avant et après : identiques, enveloppe comprise. Nous avons laissé tourner l'opérateur, vérifié que les workspaces se self-heal, et déclaré le test concluant.
Il l'était — pour une plateforme de la taille de la préprod. Ce que nous avions testé, c'était le code. Ce que nous n'avions pas testé, c'était l'horloge. Gardez cette idée en tête.
Production, un jeudi
Début décembre 2025, nous avons lancé la migration en production. La configuration était
celle prévue pour notre échelle : tous les workspaces (WORKSPACES=*), suppression
activée (DELETE_ARGOCD=true), des lots de 25 Applications avec une pause de 180
secondes entre les lots, cinq migrations concurrentes, et un timeout de 15 minutes pour
que l'opérateur réconcilie chaque Workspace.
Le run a démarré au vert. Les premières Applications ont été converties, réconciliées et supprimées exactement comme en préprod. Le job enchaînait les lots, en remplissant les logs de petites cases cochées.
Les deux cents premiers workspaces environ ont migré parfaitement.
Puis, sans que rien ne change — aucune erreur, aucun redémarrage, aucun seuil franchi — les workspaces derrière les cases cochées ont commencé à mourir.
La course que nous ne savions pas courir
Voici le mécanisme, et il est embarrassant de simplicité une fois qu'on le voit.
Le job avait récupéré toutes les Applications en un seul LIST au tout début du
run. À partir de ce moment, chaque objet Application qu'il tenait en mémoire a commencé
à vieillir. Pendant ce temps, le contrôleur d'applications d'ArgoCD continuait son
travail, rafraîchissant chaque Application à son cycle et incrémentant le
resourceVersion de chaque objet en réécrivant le status.
Pour chaque Application, le job ensuite :
- créait le Workspace CR,
- attendait — jusqu'à quinze minutes — que l'opérateur le réconcilie,
- et seulement ensuite tentait de retirer le finalizer de cascade, via un
UPDATEd'objet complet de l'objet qu'il détenait depuis le début du run.
Un UPDATE d'objet complet est un read-modify-write avec concurrence optimiste :
l'écriture transporte le resourceVersion que vous avez lu, et si l'objet vivant a
avancé depuis, le serveur API la rejette avec un 409 Conflict. Au moment où le job
arrivait à une Application — après la création et la réconciliation de son Workspace CR,
après les lots et les pauses — l'objet qu'il détenait était vieux de minutes à
heures. ArgoCD l'avait réécrit de nombreuses fois.
// l'étape de retrait, réduite à l'essentiel
finalizers, _, _ := unstructured.NestedStringSlice(app.Object, "metadata", "finalizers")
// ...on retire le finalizer ArgoCD de la copie en mémoire...
_, err := dynamicClient.Resource(applicationsGVR).
Namespace(app.GetNamespace()).
Update(ctx, app, metav1.UpdateOptions{}) // écriture d'objet complet d'un objet périmé
Pour les premières Applications, traitées quand le run était jeune, l'objet en mémoire était encore assez frais pour que l'écriture gagne la course. Le finalizer était retiré, l'Application supprimée proprement, et l'opérateur reprenait un namespace intact.
Pour chaque Application suivante, l'écriture perdait la course. Le serveur API la rejetait. Le finalizer survivait. Et le job — qui considérait un échec de retrait comme une raison de logger et de continuer, pas de s'arrêter — supprimait quand même l'Application.
Et le finalizer de cascade était une promesse. ArgoCD a supprimé chaque ressource que cette Application avait jamais créée — le ResourceQuota, le LimitRange, les NetworkPolicies, les bindings RBAC, et le namespace lui-même. Supprimer un namespace supprime tout son contenu : chaque Deployment, StatefulSet, Service, ConfigMap, Secret des étudiants, et chaque PVC avec ses données.
La courbe de péremption explique la frontière que nous avons observée. Le lot k
tournait à peu près à T0 + k × (attente de réconciliation + délai entre lots). La
probabilité qu'une Application ait été touchée par ArgoCD depuis T0 passe de «
possible » à « certaine » sur les deux premières heures. Deux cents workspaces plus
loin, le job avait franchi la ligne entre « gagne la course en général » et « la perd
toujours ». Rien dans le code n'avait changé à ce moment-là. Seule l'horloge avançait.
Le silence
Voici la partie qui me semble encore la plus troublante : rien n'a échoué.
Le job de migration a rapporté du succès, car de là où il se tenait, tout avait réussi. Le Workspace CR était créé — vrai. L'Application était supprimée — vrai aussi. Le job a terminé, affiché son résumé, et ressorti avec un code de retour nul.
ArgoCD n'a rien signalé, parce que supprimer les ressources derrière une Application avec le finalizer de cascade n'est pas une erreur — c'est le contrat. ArgoCD n'a même pas mal agi ce jour-là : quelque part dans le cluster, un contrôleur honorait fidèlement une promesse que nous avions faite un an plus tôt et oubliée.
Notre opérateur n'a rien signalé non plus. Sa boucle de réconciliation a vu des namespaces qui n'existaient plus, et a fait exactement ce pour quoi il est conçu : il a recréé l'enveloppe — namespace, quota, limit range, network policies, RBAC — par server-side apply. La plateforme avait l'air vivante. Des workspaces up, accessibles, et creux.
Et nos logs ? Le run n'a produit aucun warning qui soit parvenu à quelqu'un. Le seul composant qui aurait pu signaler le mode de panne — l'étape de retrait du finalizer — était écrit pour survivre à l'échec de son propre garde : logger, et continuer. Un garde qui n'arrête pas le run n'est pas un garde ; c'est une clause de non-responsabilité. Le post-mortem l'a trouvé dans le code en quelques minutes. Le retrouver dans les logs, après coup, au milieu d'un million de lignes vertes, c'était une autre affaire.
Les premiers signaux sont venus des utilisateurs : des workspaces up, accessibles, et vides.
Le week-end
C'est la partie de l'histoire où je peux être reconnaissant au lieu d'être malin.
Nous avions des backups Velero. De tout — les objets Kubernetes et les données des volumes. Pas parce que nous sommes des prophètes, mais parce que « le cluster mange un namespace » figurait sur notre liste de risques depuis le premier jour, et que Velero était la réponse que nous avions mise en place avant d'arrêter d'y penser.
L'équipe a passé le week-end à restaurer. Chaque namespace de workspace, chaque objet, chaque PVC et les données qu'il contenait, ramenés à l'état dans lequel ils étaient avant le run. Ce fut un travail long, peu glorieux : vérifier l'ordre de restauration, reconcilier ce qui appartenait à quoi, contrôler que chaque workspace revenait entier. Mais c'était possible, et lundi la plateforme était de retour, et l'incident est devenu une histoire au lieu d'une fin.
Deux choses ont fait la différence :
- Les backups couvraient les bonnes choses. Les objets Kubernetes et les données des volumes persistants. Un backup de l'un sans l'autre aurait restauré la lettre et perdu l'esprit.
- Personne n'a eu à improviser. La procédure de restauration existait, l'outil était installé, les backups étaient là. Le week-end a servi à exécuter, pas à concevoir.
Le correctif dont nous n'avions plus besoin
Pour être complet : le job a bien été corrigé. L'étape de retrait a été remplacée par une suppression qui demande à Kubernetes de rendre les dépendants orphelins, et — plus important — le job a appris à compter. Avant de supprimer une Application, il comptait les Deployments, StatefulSets et Services du namespace cible ; après la suppression, il recomptait, et faisait échouer l'entrée si le nombre avait baissé. Un canari par namespace, pas cher et sans pitié.
Cela n'a plus beaucoup compté, car il n'y avait alors plus rien à migrer : la cascade a fait la conversion au sens le plus littéral. Tous les workspaces étaient gérés par l'opérateur. C'est la ligne la plus sombre de cette histoire, et la plus vraie : la migration a réussi. Nous avions juste prévu qu'elle se termine par une conversion, pas par une suppression.
Quelques jours plus tard, nous avons supprimé le job de migration du dépôt. Les nouveaux workspaces naissent en Workspace CRs. Plus personne ne lancera ce job, et la prochaine plateforme n'aura jamais à le faire.
Ce que nous avons appris
1. L'échelle est une dimension de test. Nous avons testé le job sur une poignée de workspaces et il est passé, parce qu'il était correct pour une poignée de workspaces. Le mode de panne n'existe qu'aux durées de run supérieures à la fenêtre de fraîcheur des objets migrés. Le correctif de notre stratégie de test : monter en charge délibérément — 10, puis 100, puis 1 000, puis tous — et considérer qu'un run vert à une échelle donnée ne prouve rien au-delà de cette échelle.
2. Le temps est une dimension de test. La préprod était verte parce qu'elle était petite : tout le run tenait dans la fenêtre où rien n'était périmé. La production a tourné des heures, et le bug vit dans les heures. Tester en conditions réelles ne veut pas dire tester sur des données de taille production — cela veut dire tester avec des durées de forme production, ou accepter qu'un bug dépendant du temps soit invisible à un run court.
3. Jamais de read-modify-write d'état périmé sur un chemin destructif. L'étape de retrait détenait un objet pendant des minutes-heures puis réécrivait tout. Les bons patterns sont ennuyeux et connus : patcher le seul champ qui compte, ou relire l'objet et recommencer en cas de conflit, ou utiliser le server-side apply avec un field manager dédié. Nous les connaissions. L'opérateur lui-même est construit sur le server-side apply précisément parce que cela évite les courses read-modify-write. Le job de migration n'était pas tenu au même standard que la chose vers laquelle il migrait. Cette asymétrie est la vraie cause racine.
4. Un garde qui n'arrête pas le run n'est pas un garde. Le retrait du finalizer
pouvait échouer, logger, et laisser la suppression continuer. Sur un chemin qui finit par
un DELETE, chaque précondition manquée doit tout arrêter — bruyamment, et de préférence
au niveau du lot, pas de l'élément. « Warn and continue » est un défaut raisonnable pour
des retries et catastrophique pour des étapes irréversibles.
5. Mesurez des résultats, pas des étapes. Le job vérifiait ses propres actions : CR créé, Application supprimée. Deux fois vrai. Aucune des deux n'était ce qui comptait. Le job corrigé comptait les ressources du namespace avant et après — un canari qui aurait transformé la cascade silencieuse en échec franc dès le premier lot. Dix lignes de code, qu'elles auraient dû exister dès le départ.
6. Les finalizers sont des armes chargées.
resources-finalizer.argocd.argoproj.io n'est pas un détail d'implémentation ; c'est un
ordre permanent de détruire tout ce que l'objet a créé, namespace inclus. Avant toute
migration qui supprime des objets, auditez vers quoi chaque finalizer va cascader. Nous
avions écrit cet ordre nous-mêmes, un an plus tôt, et oublié qu'il était toujours en
vigueur.
7. La panne la plus dangereuse, c'est chaque composant qui fonctionne comme prévu. Le job a réussi. ArgoCD a honoré son contrat. L'opérateur a soigné les enveloppes. Personne n'a menti, rien n'a planté, rien n'a alerté — et plusieurs milliers de workspaces avaient disparu. Quand chaque couche rapporte du succès, il faut une couche qui mesure le réel, pas l'intention.
8. Les backups sont la différence entre une histoire et une fin. Velero, couvrant objets et volumes, avec une procédure de restauration à laquelle quelqu'un avait vraiment réfléchi. Le week-end a été long ; sans les backups, il vaut mieux ne pas imaginer. Les exercices de restauration sont une assurance bon marché contre le pire jour de votre trimestre.
9. Les défauts dangereux survivent à leur contexte. Le chart du job embarquait
DELETE_ARGOCD=true et WORKSPACES=* en dur — la configuration avec laquelle
l'incident a tourné. Chaque défaut d'un outil destructif doit être le réglage sûr, le
réglage dangereux devant exiger une surcharge explicite et délibérée.
À retenir
L'opérateur gère les workspaces depuis — self-heal des enveloppes, propagation du template, les deux comportements GitOps dont nous avions vraiment besoin. Il n'a jamais supprimé ce qu'il ne fallait pas, en partie parce que sa conception refuse les courses read-modify-write, et en partie parce que nous savons maintenant exactement vers quoi nos chemins destructifs peuvent cascader.
La migration est la partie de l'histoire que je voudrais le moins revivre et celle dont je suis le plus content qu'elle soit écrite. Si vous planifiez une migration entre deux systèmes de gestion, avec des milliers d'objets actifs et une étape de suppression au milieu : testez l'horloge, pas seulement le code. Patchez, ne réécrivez pas. Arrêtez tout si un garde échoue. Comptez ce qui existe avant et après. Et gardez des backups ennuyeux, complets, et répétés.
L'alternative, c'est un flux de logs très silencieux, une ligne de résumé bien verte, et un lundi matin plein de namespaces vides.