Pluto

Lors du passage de la v1beta à la v1, j’ai vécu l’enfer de la gestion des versions d’API dans Kubernetes. Cette expérience m’a fait prendre conscience de l’importance d’un suivi rigoureux des versions d’API. Sans outil adapté, on risque des interruptions de service imprévues et des heures de débogage fastidieuses. C’est là qu’intervient Pluto, un outil qui simplifie la détection des versions dépréciées dans les manifests kubernetes et évite bien des surprises lors des mises à jour de Kubernetes.

Comprendre les dépréciations d’API Kubernetes

Kubernetes évolue rapidement, et avec chaque nouvelle version, certaines API sont modifiées, dépréciées ou supprimées. Cela signifie que des ressources fonctionnelles aujourd’hui peuvent cesser de l’être dans une future mise à jour.

Pourquoi Kubernetes déprécie-t-il certaines API ?

Chaque version de Kubernetes apporte des améliorations en termes de performance, sécurité et maintenabilité. Pour cela, les anciennes API sont parfois remplacées par des versions plus robustes et standardisées.

Voici quelques raisons courantes de dépréciation :

• Évolution des meilleures pratiques : certaines API deviennent obsolètes au profit de nouvelles approches.
• Amélioration de la stabilité : les API en beta sont souvent retirées pour être remplacées par une version stable (v1).
• Optimisation des performances : certaines API inefficaces sont supprimées pour réduire la charge sur l’API serveur.

Impact des API dépréciées sur vos clusters

Si vous utilisez une API dépréciée sans le savoir, plusieurs problèmes critiques peuvent apparaître :

• Échecs de déploiement : les ressources définies avec une ancienne API ne seront plus reconnues après une mise à jour.
• Comportements inattendus : certaines fonctionnalités peuvent changer sans avertissement, entraînant des bugs difficiles à diagnostiquer.
• Incompatibilité avec les nouveaux outils : certains services Kubernetes modernes nécessitent l’utilisation d’API récentes.

Par exemple, lors du passage de v1beta1 à v1 pour Ingress, de nombreux manifestes ont cessé de fonctionner car la structure des champs avait changé. Ce genre de situation peut rapidement casser un déploiement en production si elle n’est pas anticipée.

Comment anticiper ces changements ?

Pour éviter ces désagréments, il est essentiel de :

• Suivre les annonces de Kubernetes sur les nouvelles versions et les API dépréciées (Kubernetes Deprecated API ↗).
• Utiliser des outils d’analyse comme Pluto pour détecter les API obsolètes dans vos manifestes et vos charts Helm.
• Mettre à jour régulièrement vos configurations pour éviter une accumulation de dettes techniques.

Présentation de Pluto

Lorsque j’ai découvert Pluto, j’ai immédiatement compris son utilité : un outil simple et efficace pour détecter les API Kubernetes dépréciées. Développé par Fairwinds, Pluto permet d’identifier rapidement les ressources qui utilisent des versions obsolètes et d’anticiper les migrations avant qu’elles ne causent des interruptions de service.

Qu’est-ce que Pluto et à quoi sert-il ?

Pluto est un outil en ligne de commande (CLI) qui analyse les fichiers de configuration Kubernetes et les charts Helm pour détecter les versions d’API dépréciées ou supprimées. Il permet ainsi de :

• Lister les API obsolètes dans les manifests Kubernetes et Helm.
• Anticiper les changements avant une mise à jour du cluster.
• Faciliter la transition vers des versions plus récentes des API.

C’est un outil léger et rapide, idéal pour intégrer dans un pipeline CI/CD afin d’automatiser la détection des obsolescences.

Comment fonctionne Pluto ?

Pluto analyse plusieurs types de ressources Kubernetes :

1. Manifests statiques : fichiers YAML définissant vos ressources Kubernetes.
2. Charts Helm : analyse des définitions de ressources dans vos packages Helm.
3. Releases Helm actives : scan des déploiements Helm installés dans le cluster.

Il affiche ensuite un rapport clair indiquant les ressources concernées, la version de l’API utilisée et la version recommandée pour la mise à jour.

Exemple d’utilisation de Pluto

Voici un aperçu d’une commande Pluto et de son résultat :

pluto detect-files -d ./manifests

NAME              KIND      VERSION              REPLACEMENT            REMOVED   DEPRECATED   REPL AVAIL
example-ingress   Ingress   extensions/v1beta1   networking.k8s.io/v1   true      true         true

Ici, Ingress utilise encore la version v1beta1, qui a été dépréciée en 1.19 et supprimée en 1.22. Cela signifie qu’une mise à jour est nécessaire avant de passer à Kubernetes 1.22. Un vieux souvenir.

Installation de Pluto

Avant de pouvoir utiliser Pluto, il faut l’installer sur votre environnement de travail. Heureusement, son installation est simple et rapide, que ce soit sur Linux, macOS ou Windows.

Installation sur Linux et macOS

Pluto est distribué sous forme de binaire et peut être installé avec Homebrew ou en téléchargeant le binaire depuis GitHub.

Via Homebrew

Si vous utilisez Homebrew, la méthode la plus simple est :

brew install FairwindsOps/tap/pluto

Une fois l’installation terminée, vérifiez que Pluto est bien installé avec :

pluto --version

Via asdf-vm

Si vous utilisez asdf-vm, vous pouvez installer Pluto avec le plugin asdf-pluto :

asdf plugin add pluto
asdf install pluto latest
asdf set -home pluto latest

Installation manuelle

Si vous préférez télécharger directement le binaire, voici comment procéder :

1. Récupérez le dernier binaire disponible sur la page des releases de Pluto ↗.

2. Téléchargez et extrayez l’archive :

   wget https://github.com/FairwindsOps/pluto/releases/latest/download/pluto_<release>_<os>_<archi>.tar.gz
   tar -xzf pluto_<release>_<os>_<archi>.tar.gz

   Remplacez <release>, <os> et <archi> par les valeurs correspondant à votre système.

3. Déplacez le binaire vers /usr/local/bin/ pour pouvoir l’utiliser globalement :

   sudo install pluto /usr/local/bin/

4. Vérifiez l’installation :

   pluto --help
   
    completion            Generate the autocompletion script for the specified shell
    detect                Checks a single file or stdin for deprecated apiVersions.
    detect-all-in-cluster run all in-cluster detections
    detect-api-resources  detect-api-resources
    detect-files          detect-files
    detect-helm           detect-helm
    help                  Help about any command
    list-versions         Outputs a JSON object of the versions that Pluto knows about.
    version               Prints the current version of the tool.
   
    ...
   
   Use "pluto [command] --help" for more information about a command.

Installation sur Windows

Pour Windows, vous pouvez télécharger l’exécutable Pluto depuis GitHub ↗ et l’ajouter à votre PATH.

Autre option : utiliser Chocolatey :

choco install pluto

Une fois installé, testez la version :

pluto --version

Intégration dans un conteneur

Si vous souhaitez utiliser Pluto dans un pipeline CI/CD ou un environnement conteneurisé, voici comment l’exécuter directement avec Docker :

docker run --rm quay.io/fairwinds/pluto:latest pluto --help

Cela permet d’éviter une installation locale et de garantir l’utilisation de la dernière version.

Vérification de l’installation

Pour vérifier que Pluto est correctement installé, exécutez la commande suivante dans votre terminal :

pluto version
Version:5.21.3 Commit:282bddb2e5a1e8a9398da41a896367995cee97ff

Utilisation de Pluto

Pluto permet de détecter les API Kubernetes dépréciées dans différents contextes :

• Fichiers locaux contenant des manifests Kubernetes.
• Releases Helm en cluster pour identifier les API obsolètes dans les déploiements Helm.
• Charts Helm locaux avant leur déploiement.
• API resources actives dans un cluster Kubernetes.

Voyons comment utiliser Pluto dans ces différents cas.

Détection des fichiers manifests dans un répertoire

Pour scanner un répertoire contenant des fichiers YAML, utilisez la commande :

pluto detect-files -d <CHEMIN_DU_REPERTOIRE>

Par exemple :

pluto detect-files -d manifests/

NAME        KIND         VERSION              REPLACEMENT   REMOVED   DEPRECATED
utilities   Deployment   extensions/v1beta1   apps/v1       true      true
utilities   Deployment   extensions/v1beta1   apps/v1       true      true

Ici, Pluto a détecté que le Deployment utilise extensions/v1beta1, qui est déprécié et remplacé par apps/v1. Il faudra mettre à jour ces fichiers avant de migrer vers une version plus récente de Kubernetes.

Options utiles :

• Spécifier les extensions à analyser :

  pluto detect-files -d manifests --extensions yaml,yml

• Ignorer certains répertoires :

  pluto detect-files -d manifests --ignore-dir old_manifests/

• Sortie détaillée (wide, JSON, YAML) :

  pluto detect-files -d manifests -o wide

Détection des API dépréciées dans un cluster Helm

Si vous utilisez Helm, Pluto peut analyser les releases installées dans votre cluster et identifier celles qui utilisent des API obsolètes :

pluto detect-helm -o wide

Restreindre l’analyse à un namespace spécifique :

pluto detect-helm -n cert-manager -o wide

Cela affichera uniquement les releases dans le namespace cert-manager.

Vérification d’un Helm Chart local avant son déploiement

Pour éviter de déployer un chart Helm avec des API dépréciées, utilisez cette commande :

helm template <CHEMIN_DU_CHART> | pluto detect -

Exemple :

helm template e2e/tests/assets/helm3chart | pluto detect -

Détection des API utilisées dans le cluster

Pour analyser toutes les ressources en cours d’utilisation dans le cluster, utilisez :

pluto detect-api-resources -o wide

There were no resources found with known deprecated apiVersions.

Vérification complète de toutes les API utilisées (Helm + Kubernetes)

Pour analyser toutes les ressources en cluster, y compris les releases Helm et les API natives Kubernetes, utilisez :

pluto detect-all-in-cluster -o wide 2>/dev/null

Gestion des versions cibles

Pluto cible par défaut Kubernetes v1.22.0, mais vous pouvez personnaliser cette version avec --target-versions :

pluto detect-helm --target-versions k8s=v1.32.0

Cela permet d’anticiper la migration vers une version future de Kubernetes.

Gestion des codes de sortie de Pluto

Pluto retourne des codes d’erreur spécifiques en fonction des résultats :

Code	Signification
1	Une erreur s’est produite
2	Une API dépréciée a été trouvée
3	Une API supprimée a été trouvée
4	Aucune version de remplacement disponible

Pour éviter l’échec d’un script CI/CD sur des API seulement dépréciées, utilisez l’option --ignore-deprecations :

pluto detect-files -d manifests --ignore-deprecations

Pour ignorer aussi les API supprimées (à éviter en production) :

pluto detect-files -d manifests --ignore-deprecations --ignore-removals

Conclusion

Pluto est un outil incontournable pour toute équipe qui gère des déploiements Kubernetes. Il permet d’identifier rapidement les API obsolètes, d’anticiper les migrations et d’éviter les interruptions de service lors des mises à jour du cluster.

Grâce à sa flexibilité, Pluto peut être utilisé en local pour analyser des fichiers YAML ou en cluster pour scanner des releases Helm et des API en cours d’utilisation. Il offre aussi des fonctionnalités avancées comme la gestion des versions cibles et l’intégration dans un pipeline CI/CD.

À intégrer dans votre pipeline CI/CD !!!

Je vous recommande d’exécuter Pluto à chaque push, que ce soit sur la branche main/master ou sur d’autres branches, afin de détecter les API obsolètes dès le début du cycle de développement. Cela évite l’accumulation de dette technique et garantit que vos manifestes et vos Helm Charts resteront compatibles avec les versions futures de Kubernetes.

Voici un exemple de commande à inclure dans votre pipeline CI/CD :

pluto detect-files -d manifests --target-versions k8s=v1.33.0

En automatisant cette vérification, vous assurez une transition fluide vers les nouvelles versions de Kubernetes et réduisez les risques d’interruption en production.

N’attendez pas qu’une mise à jour casse vos déploiements : adoptez Pluto dès maintenant !

Pour aller plus loin

• Site officiel de Pluto ↗
• Repository GitHub de Pluto ↗