Aller au contenu principal

La migration qui a supprimé tous les workspaces : une histoire de guerre Kubernetes

Nous avons migré les workspaces de nos étudiants depuis des Applications ArgoCD vers un opérateur maison. La répétition est passée, la production a tourné au vert, et à la fin du run, tous les workspaces créés après les deux cents premiers avaient été supprimés — en silence. Voici l'histoire complète : la mécanique de la panne, le week-end de restauration, et ce que nous faisons différemment maintenant.

JV

Joël Vappiani

20 min

Partager sur X

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 :

CoucheCe que l'étudiant obtientCe dont la plateforme est protégée
NamespaceUn endroit privé pour déployerCollisions de noms, accès inter-tenant
ResourceQuotaUn budget CPU/mémoire/stockage prévisibleUn workspace qui affame tout le cluster
LimitRangeDes requests et limits par défautLes pods sans limits qui passent au travers
RBACadmin dans son namespace, et rien d'autreLes étudiants qui agissent hors de leur workspace
NetworkPolicyDefault-deny, ingress/egress explicitesLe trafic inter-namespace, l'egress inattendu
Pod Security Admissionbaseline en enforcementLes 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 :

  1. 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.
  2. 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.
  3. 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.
  4. 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 à managedFields qui 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 :

  1. Convertir l'Application ArgoCD en Workspace CR (même nom, même namespace cible, utilisateur et invités extraits des Helm values) ;
  2. Créer le Workspace CR et attendre que l'opérateur le réconcilie — polling jusqu'à ce que le workspace passe Active avec toutes les ressources de l'enveloppe créées ;
  3. Retirer le finalizer de cascade de l'Application, pour que sa suppression ne supprime que l'objet Application ;
  4. 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 :

  1. créait le Workspace CR,
  2. attendait — jusqu'à quinze minutes — que l'opérateur le réconcilie,
  3. et seulement ensuite tentait de retirer le finalizer de cascade, via un UPDATE d'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.