Les Helm charts sont-ils adaptés aux petits projets ?

Le débat rate la vraie question : ce n'est pas la taille du projet qui compte, mais le nombre de combinaisons de configuration à tenir.

Les Helm charts sont-ils adaptés aux petits projets ?

Ce que Helm résout vraiment

Un Helm chart n'est pas un outil de déploiement, c'est un moteur de template. Tu écris des manifestes Kubernetes troués — {{ .Values.image.tag }}, {{ .Values.resources }} — et Helm les remplit avant de les envoyer à l'API. Le gain réel tient en trois choses : un artefact versionné pour plusieurs environnements, un rollback atomique, et une release identifiée dans le cluster.

Sur un projet à trois services, tu obtiens ces trois choses en écrivant deux kubectl apply -k. Le chart te coûte alors un Chart.yaml, un values.yaml, un dossier templates/ avec ses _helpers.tpl, et la charge mentale de savoir ce que fabrique un toYaml .Values.resources | nindent 12.

Exemple concret : un déploiement web, un worker et un Redis font 180 lignes de YAML brut. Le chart équivalent en pèse 320 avant la première ligne de values, dont une quarantaine dans les helpers que plus personne ne relit. La documentation Helm sur les bonnes pratiques recommande d'ailleurs de garder les templates lisibles — un aveu : la lisibilité est le problème numéro un.

Le coût réel d'un chart sur un petit projet

Le coût n'apparaît pas le jour de la création, il apparaît au premier incident. À 2 h du matin, tu débogues un manifeste qui n'existe nulle part sur le disque : il faut helm get manifest pour voir la vérité. Un kubectl get deploy -o yaml ne suffit plus, il te manque la couche de valeurs.

Deuxième coût, la reproductibilité. Ton values.yaml par défaut dérive, les overrides s'empilent, et plus personne ne sait quelle combinaison tourne. Le classique du genre : helm upgrade -f values.yaml -f secrets.yaml en prod, helm upgrade tout court en staging, et un écart de configuration qui ne se réveille qu'en production.

Troisième coût, les upgrades de charts tiers. Une dépendance qui renomme trois clés entre deux versions mineures casse ton values.yaml en silence. Tu passes la soirée à lire un diff de CRD pour un composant que tu n'as pas écrit.

L'argument inverse, et il est solide

Dire « Helm est trop lourd » est devenu un lieu commun, et c'est souvent faux. L'argument tient dès que le nombre de manifestes dépasse ce qu'un humain peut tenir en tête : au-delà de huit à dix ressources avec plusieurs environnements, le template redevient rentable. Idem si tu distribues ton logiciel : sans chart, tu imposes à tes clients de recopier du YAML, et ils le feront mal.

Autre cas massif, les composants d'infrastructure. Installer cert-manager, ingress-nginx ou Prometheus à la main est un exercice de patience inutile. Là, le chart tiers avec ses valeurs par défaut testées vaut largement le coût d'apprentissage.

La documentation Kubernetes sur la configuration rappelle que tout doit être versionné et déclaratif — un chart bien fait applique ce principe, un kubectl apply manuel beaucoup moins.

Et le helm rollback reste imbattable sur une release cassée. Un kubectl rollout undo ne couvre que les Deployments, pas les ConfigMaps, Secrets, CRD ou Jobs modifiés dans le même lot.

Trois signaux qui disent « passe à Helm »

Premier signal : tu maintiens plus de trois environnements avec des valeurs différentes. À ce stade, tes overlays commencent à ressembler à un moteur de template maison, et tu réinventes Helm en moins bien.

Deuxième signal : tu installes au moins un composant tiers maintenu par la communauté. Le chart est le chemin officiel, avec ses notes de version et ses migrations documentées.

Troisième signal : ton équipe sait déjà lire un values.yaml. helm lint et helm template dans la CI coûtent une ligne chacun et attrapent les erreurs de valeurs avant le cluster.

À l'inverse, trois signaux disent « laisse tomber » : un seul environnement, moins de cinq ressources, aucun composant tiers. Ajoute un quatrième, décisif : tu es seul à maintenir le projet et tu n'as pas de temps pour les upgrades de charts. Dans ces cas, Kustomize couvre 90 % du besoin avec un kustomization.yaml et quelques patchs, sans couche de template.

L'entre-deux que personne ne documente

Le vrai piège est binaire : soit du YAML brut, soit un chart complet avec 400 lignes de values. Il existe une troisième voie, le chart minimal.

Un Chart.yaml, un values.yaml à cinq clés — image, tag, replicas, resources, env — et des templates qui font toYaml du reste. Tu gardes le rollback et les releases, tu abandonnes la flexibilité que tu n'utilisais pas.

Sur un petit projet, mon values.yaml fait 22 lignes pour trois fichiers de templates. Changer d'environnement tient en un --set image.tag=1.4.2. Les readiness probes sont écrites une fois dans le template et jamais recopiées — exactement le genre de détail qui casse quand on duplique des manifestes, comme je le détaillais dans les enseignements des readiness probes.

L'autre levier, c'est de tenir le chart sous surveillance. helm diff upgrade avant chaque release, helm lint en CI.

Sans ces deux commandes, un chart dérive en décorations que personne n'ose toucher. C'est la même logique que pour n'importe quel déploiement : la valeur vient du processus, pas de l'outil, comme dans le déploiement de Kubernetes en production.

Ma règle, en une phrase

Un chart se justifie quand il remplace plus de travail humain qu'il n'en crée : à partir de plusieurs environnements et d'un composant tiers, oui ; pour trois manifestes sur un cluster unique, non.

Le débat « les Helm charts sont-ils adaptés aux petits projets » rate souvent la vraie question. Ce n'est pas la taille du projet qui compte, c'est le nombre de combinaisons de configuration que tu dois tenir.

Trois services multipliés par quatre environnements font douze configurations : là, un chart minimal te fait gagner du temps. Un service sur un environnement fait une configuration : kubectl apply -k suffit, et tu viens d'économiser un outil.