Mes clients ont presque tous le même besoin : déployer leurs apps proprement, avec des environnements de preview, des secrets bien rangés et vraiment secrets, des backups et de l’observabilité, sans recruter quelqu’un dont c’est le métier. Au fil des missions, j’ai fini par construire la plateforme que je montais à la main chez chacun d’eux. Elle s’appelle justshipit. L’idée : on pousse son code, on obtient une URL, et on ne voit jamais Kubernetes, Argo CD, Grafana ni le gestionnaire de secrets.
Aujourd’hui, elle fait tourner mon infra. Voici comment elle est construite, ce qu’elle applique par défaut, comment l’IA y est bornée, et ce qui n’est pas encore fait.
En bref
- Un hub Kubernetes sous Talos chez Hetzner, et un vCluster par client. Chaque client a son propre API server, ses quotas, ses règles réseau, et ses pods tournent sur des nœuds partagés ou dédiés à son vCluster.
- Du push à l’URL en ligne en 122 secondes, une preview par pull request en 62 secondes.
- Les bonnes pratiques sont dans le chart par défaut : probes, presets de ressources, conteneurs non-root en lecture seule. Personne n’a à y penser.
- L’IA diagnostique les incidents et code dans un cadre : lecture seule par défaut, actions seulement proposées, la CI comme seule preuve.
Le but de la plateforme
La promesse tient en une phrase : une alternative à Heroku hébergée en Europe, au prix de Hetzner, où chaque client a un vrai cluster.
Le parcours visé : inscription, création d’une app depuis un template ou un repo existant, git push, URL en ligne. Autour : variables d’environnement, bases de données, logs, domaines, rollbacks, facture. Tout ce qu’on modifie dans la console devient un commit git, donc tout est traçable et réversible.
Si tu te poses la question de quitter Heroku, j’ai comparé les options du marché dans un article dédié.
Architecture : un hub et des vClusters
Le hub
Le hub tourne chez Hetzner, à Falkenstein, sous Talos Linux : un OS immuable, piloté par API, sans SSH. C’est la même base que ma migration de Kapsule vers Talos, en plus gros, avec le cluster-autoscaler qui ajoute des nœuds quand la charge monte.
La stack : Cilium et Traefik pour le réseau, CloudNativePG et Velero pour les données, OpenBao et External Secrets pour les secrets, Argo CD et Forgejo pour le déploiement et la CI, VictoriaMetrics, VictoriaLogs et VictoriaTraces pour l’observabilité, HPA et VPA pour dimensionner les apps.
Les secrets du hub lui-même ne sont pas dans OpenBao, qui tourne dessus : ils sont chiffrés avec SOPS et une clé KMS. Si le hub tombe, on le reconstruit sans dépendre de ce qui tournait dessus.
Un vCluster par client
Chaque client a son vCluster, dans un namespace dédié du hub. Un vCluster, c’est un vrai API server Kubernetes qui tourne dans un pod. Le client voit un cluster complet, avec ses namespaces, ses CRD et son RBAC. Ses pods, eux, redescendent sur les nœuds du hub, partagés ou dédiés à son vCluster selon l’offre.
Chaque vCluster a un plancher non négociable : Pod Security en baseline, des quotas, une NetworkPolicy qui interdit le trafic entre namespaces, aucun NodePort. Autour, un projet Argo CD verrouillé sur ses repos et une policy OpenBao limitée à ses secrets.
Au départ, je donnais un cluster Talos complet à chaque client : isolation maximale, mais 3 control planes par client à payer et à maintenir. Le vCluster donne un vrai cluster à chacun pour une fraction du coût, avec une limite : la version open source ne synchronise pas les CRD arbitraires.
L’opérateur Tenant
La création d’un client est pilotée par un opérateur Kubernetes écrit en Go. Une ressource Tenant décrit le client, et l’opérateur crée tout dans l’ordre : identité, vCluster, DNS et certificat, secrets, Argo CD, organisation Forgejo et premier repo. À la suppression, il démonte tout dans l’ordre inverse.
Le sous-domaine d’un client est dérivé d’un HMAC de son email, pas de son nom : les certificats TLS sont publics dans les logs Certificate Transparency, et un sous-domaine en prenom-nom y serait lisible par tout le monde.
Du push à la prod
Templates et repos existants
Une app démarre depuis l’un des 11 templates (Go, Next.js, Python, PHP, Java, Rust, Node, Ruby, Elixir, statique, frontend) ou depuis un repo existant. Les templates partagent un contrat simple : l’app écoute sur PORT, répond sur /health, tourne en non-root et accepte un système de fichiers en lecture seule. Pour un repo existant, la plateforme injecte un Dockerfile et les workflows de build.
Mesuré :
- 122 secondes entre le push et l’URL en ligne pour un repo importé ;
- environ 100 secondes pour une vraie app Python depuis un template.
CI
La CI tourne sur des runners Forgejo Actions. Un scaler maison lit la file des jobs et ajuste le nombre de runners entre 2 et 4. Chaque build est plafonné à 3 CPU pour ne pas affamer son nœud.
Previews de pull request
Chaque pull request obtient sa propre URL, dans son propre namespace, avec un ApplicationSet Argo CD. La preview est en ligne en 62 secondes, et supprimée 60 secondes après la fermeture de la PR. On peut la restreindre à une liste d’IP. J’ai détaillé le principe dans mon article sur les environnements éphémères.
DNS, TLS, secrets
- DNS : external-dns, avec une instance par zone du client et ses propres identifiants chez son registrar (OVH, Cloudflare, Scaleway, Gandi, DigitalOcean). Un nom de domaine déjà pris par un autre client est refusé.
- TLS : un certificat wildcard par client en DNS-01, et Let’s Encrypt en HTTP-01 pour les domaines personnalisés.
- Secrets : rangés dans OpenBao par client et par app, injectés en variables d’environnement par External Secrets. La console agit avec le token OpenBao de l’utilisateur connecté, pas avec un compte de service tout-puissant : ce sont les policies OpenBao qui décident de ce qu’il peut voir.
Observabilité et backups
- Métriques et logs conservés 30 jours, traces 7 jours. La console montre les métriques du client, ses logs en direct et ses logs de build.
- Chaque alerte pointe vers un runbook.
- Velero sauvegarde tous les vClusters chaque nuit, avec 30 jours de rétention.
Les bonnes pratiques par défaut
C’est le cœur de ce que j’apporte à un client : les réglages que je corrigeais à la main à chaque audit sont appliqués d’office.
Un seul chart pour toutes les apps
Toutes les apps passent par le même chart Helm, qui gère le Deployment, les workers, les CronJobs, l’autoscaling, l’Ingress, les secrets, le scraping des métriques et les add-ons (Valkey, Postgres, Supabase). C’est le même principe que le chart générique que j’utilise pour plus de 100 apps.
Des presets de ressources
On ne demande pas à un développeur de choisir des requests et des limits. Il choisit un preset :
| Preset | CPU request | Mémoire request | Mémoire limit | Replicas |
|---|---|---|---|---|
| eco | 10m | 32 Mi | 128 Mi | 1 |
| standard | 100m | 128 Mi | 512 Mi | 1 |
| performance | 250m | 512 Mi | 1 Gi | 2, jusqu’à 4 à 80 % de CPU |
Pas de limit CPU, volontairement : elle provoque du throttling sans rien protéger. Les runtimes gourmands ont un plancher (Java démarre à 500m et 512 Mi). Le raisonnement complet est dans mon article sur l’allocation des ressources.
Le VPA recale, la facture suit l’usage
Un preset reste une estimation. Le Vertical Pod Autoscaler la corrige à partir de 8 jours d’usage réel, une fois par semaine pour ne pas se battre avec le HPA, et sans redémarrer l’app. La facture suit la même logique : un abonnement par siège et par app, plus l’usage réel mesuré chaque jour. Quand le VPA réduit ce qu’une app réserve, la facture baisse avec.
Sécurité et disponibilité
- Probes liveness, readiness et startup sur
/health. - Conteneurs en non-root, système de fichiers en lecture seule, toutes les capabilities retirées, pas d’escalade de privilèges, profil seccomp par défaut. C’est le niveau
restricteddes Pod Security Standards, alors que le namespace n’impose quebaseline. - Rolling update à 25 % d’indisponibilité maximum et 50 % de surplus.
Il n’y a pas de policy engine en production : les garanties viennent du chart, des Pod Security Standards, du RBAC, des quotas et des NetworkPolicy. Un client qui écrit ses propres manifests reste dans son vCluster, mais rien ne l’empêche de déployer un pod sans probe.
L’IA, dans un cadre strict
Diagnostiquer les incidents
Quand une alerte se déclenche, un superviseur lance un agent dans une copie du repo GitOps et de ses runbooks. L’agent regarde l’état du cluster, le croise avec les commits récents et poste un diagnostic dans Slack : cause, périmètre, remédiation proposée, niveau de confiance.
- Lecture seule : kubectl sans accès aux Secrets, et aucun token dans son environnement. Une injection de prompt n’a rien à exfiltrer.
- Des actions proposées, pas exécutées : redémarrer, supprimer un pod, scaler, 3 actions au maximum, annoncées dans Slack 10 minutes avant. Une réaction 🛑 les annule, et en cas de doute, rien ne se passe.
- Des correctifs par pull request, limités aux manifests, et rien ne bouge pendant un backup.
Coder son app
Chaque app a un espace de travail : un éditeur dans le navigateur, un terminal, et des agents de code qui utilisent les clés d’IA du client. On confie une tâche à un agent depuis un tableau de cartes, et un second agent relit, au besoin sur un autre modèle.
- Le rayon d’explosion, c’est une app : rôle
editsur son namespace, API du hub injoignable, accès aux seuls secrets de l’app. - Les fichiers sensibles (CI, authentification, facturation, migrations) et les écritures en base attendent l’approbation d’un humain.
- La CI fait foi : la review d’un agent n’est pas une preuve, et la mise en prod se fait sur approbation par défaut.
Ce n’est pas une sandbox contre un processus hostile, et c’est écrit noir sur blanc dans la doc.
Ce qui n’est pas encore fait
- Les nœuds dédiés par client : le code est prêt, mais aucun pool n’est encore provisionné.
- L’autoscaling sur le temps de réponse : scaler sur les p50 et p90 de latence plutôt que sur le CPU, qui ne dit pas si les utilisateurs attendent.
- La mise en veille automatique : suspendre une app qui ne reçoit plus de requêtes et la réveiller à la suivante, pour ne rien payer quand personne ne s’en sert.
- Une partie de l’opérateur : les étapes app et add-ons sont encore des coquilles vides.
- La vérification indépendante : un runner qui revérifie le travail des agents hors de leur environnement. Tant qu’il n’est pas livré, les projets qui l’activent ne déploient rien.
- Un policy engine pour les clients qui écrivent leurs propres manifests.
- Le PodDisruptionBudget activé par défaut : il existe dans le chart, mais il est désactivé.
Mon avis
Construire une plateforme, c’est surtout décider de ce que personne ne devra plus faire à la main : choisir des requests, configurer un certificat, penser aux backups, relire un diff de 300 lignes écrit par une IA.
L’IA y est utile à une condition : qu’elle ne puisse rien casser seule. Lecture seule par défaut, actions proposées, veto humain, la CI comme preuve. Le jour où un agent se trompe, il se trompe sur une app, pas sur la plateforme.
Tu veux le même niveau de cadre sur ton propre cluster, avec ou sans justshipit ? C’est ce que je regarde pendant un audit de cluster Kubernetes.
Points clés à retenir
- ✓ Un hub Talos chez Hetzner et un vCluster par client : un vrai API server par client, des pods sur des nœuds partagés ou dédiés
- ✓ Du push à l'URL en ligne en 122 s, une preview par pull request en 62 s
- ✓ Presets de ressources, probes et conteneurs non-root en lecture seule appliqués par défaut, sans policy engine
- ✓ L'agent d'incident lit, propose et attend : actions annoncées 10 min avant, veto humain, rien pendant un backup
- ✓ Les agents de code ne peuvent casser qu'une app : rôle limité au namespace, fichiers protégés, la CI comme seule preuve