Automatiser les namespaces dans vos projets
Un namespace créé à la main diverge en trois semaines. Voici comment le décrire en code avec ses quotas, ses droits et son réseau — et le recréer à l'identique.
Un namespace créé à la main tient trois semaines. Au quatrième sprint, il a un quota à moitié rempli, deux ServiceAccounts non documentés et zéro NetworkPolicy. La personne qui l'a créé est partie en vacances, et personne ne sait si le suffixe -prod est réellement la production.
Automatiser les namespaces, ce n'est pas écrire un kubectl create ns dans un script. C'est décrire l'unité de cloisonnement de ton cluster comme du code, avec ses quotas, ses droits et son réseau, puis laisser une machine la recréer à l'identique.
Pourquoi les namespaces manuels finissent toujours par diverger
Le namespace est l'objet Kubernetes le plus simple à créer et le plus facile à oublier. Un kubectl create namespace paiement renvoie created en 200 ms, sans quota, sans limite de ressources, sans isolation.
Sur un cluster de staging, ça passe. Sur un cluster qui héberge huit équipes, tu te retrouves avec un namespace où un pod peut consommer 64 Go de RAM et asphyxier les voisins. J'ai vu un cluster de démonstration tomber parce qu'un namespace de test n'avait aucune LimitRange et qu'un stress-ng lancé « pour vérifier » a saturé la mémoire du nœud unique.
Le vrai coût n'est pas technique, il est cognitif : chaque namespace devient une exception qu'il faut redécouvrir. La solution tient en une idée — un namespace est un livrable, il se versionne, se relit et se déploie comme le reste.
Un namespace, c'est cinq objets, pas un
Quand tu automatises, la liste des objets à créer en même temps que le namespace lui-même est stable. Elle tient dans un tableau.
| Objet | Rôle | Oublié dans la nature |
|---|---|---|
Namespace | Le contenant, ses labels | rarement |
ResourceQuota | Plafond CPU/RAM/objets | 9 fois sur 10 |
LimitRange | Valeurs par défaut des conteneurs | 9 fois sur 10 |
RoleBinding | Qui a le droit d'y toucher | souvent remplacé par un cluster-admin |
NetworkPolicy | Isolation du trafic entrant | presque toujours |
Le manifest de base
Un fichier unique, lisible en revue, qui contient le contenant et ses labels. Les labels sont ce qui permettra plus tard de retrouver le propriétaire et l'environnement.
apiVersion: v1
kind: Namespace
metadata:
name: paiement-staging
labels:
team: paiement
env: staging
cost-center: fintech-01
managed-by: platform
Le label managed-by n'est pas décoratif. C'est lui qui autorisera ton outil de nettoyage à supprimer un namespace sans toucher à ceux créés par un humain pressé. Sur un cluster réel, ce détail a évité la suppression d'un namespace de production créé manuellement par un CTO.
ResourceQuota et LimitRange : le garde-fou
Sans quota, un namespace est une promesse non tenue. Le quota plafonne l'ensemble, la LimitRange donne des valeurs par défaut aux conteneurs qui n'en déclarent pas.
apiVersion: v1
kind: ResourceQuota
metadata:
name: quota
namespace: paiement-staging
spec:
hard:
requests.cpu: "4"
requests.memory: 8Gi
limits.cpu: "8"
limits.memory: 16Gi
pods: "40"
services.loadbalancers: "1"
---
apiVersion: v1
kind: LimitRange
metadata:
name: defaults
namespace: paiement-staging
spec:
limits:
- type: Container
default:
cpu: 200m
memory: 256Mi
defaultRequest:
cpu: 100m
memory: 128Mi
Attention à un piège classique : dès qu'un ResourceQuota existe, tout pod sans requests ni limits est rejeté. La LimitRange n'est donc pas optionnelle, elle est la condition de fonctionnement du quota. Si tu veux creuser l'impact des quotas sur les déploiements réels, l'article sur les limites des namespaces trop souvent ignorées détaille les cas de blocage.
Générer les namespaces d'un projet avec Kustomize
Écrire cinq fichiers par namespace pour huit équipes donne quarante fichiers. Kustomize résout ça sans templating : une base, des overlays, des noms générés.
# base/kustomization.yaml
apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization
resources:
- namespace.yaml
- quota.yaml
- limitrange.yaml
- networkpolicy-default-deny.yaml
# overlays/paiement-staging/kustomization.yaml
apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization
namespace: paiement-staging
resources:
- ../../base
labels:
- pairs:
team: paiement
env: staging
includeSelectors: false
patches:
- target:
kind: ResourceQuota
name: quota
patch: |-
- op: replace
path: /spec/hard/limits.memory
value: "8Gi"
La commande de rendu tient en une ligne, et le résultat se commite ou s'applique directement :
kubectl kustomize overlays/paiement-staging | kubectl apply -f -
L'intérêt réel n'est pas la concision, c'est la revue. Un diff sur un overlay montre exactement ce qui change pour une équipe, sans bruit sur les autres. Le jour où le quota par défaut passe de 16 à 24 Gi, tu modifies la base et les huit overlays suivent.
Un chart Helm « tenant » pour les cas répétitifs
Kustomize brille quand la structure est stable. Helm reste plus pratique quand tu dois créer N namespaces presque identiques avec des valeurs qui viennent d'un fichier par équipe.
# values/paiement.yaml
team: paiement
env: staging
quota:
cpu: "4"
memory: 8Gi
owners:
- yannic
Le template du chart itère sur ces valeurs et pose les cinq objets d'un coup. Une boucle shell suffit à provisionner toute une organisation :
for f in values/*.yaml; do
team=$(yq -r .team "$f")
env=$(yq -r .env "$f")
helm upgrade --install "ns-$team-$env" ./charts/tenant \
-n "$team-$env" --create-namespace -f "$f"
done
Un détail qui compte : --create-namespace crée le namespace mais ne pose aucun label. Fais du namespace lui-même une ressource du chart plutôt qu'un effet de bord de Helm, sinon tu perds le bailleur de propriété au premier helm uninstall.
RBAC automatique : un rôle par namespace, pas un cluster-admin
L'automatisation des droits est la partie que les équipes sautent, et c'est celle qui coûte le plus cher en audit. La règle est simple : un développeur reçoit un rôle dans son namespace, jamais une clé de cluster-admin.
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
name: dev-edit
namespace: paiement-staging
subjects:
- kind: Group
name: paiement-devs
apiGroup: rbac.authorization.k8s.io
roleRef:
kind: ClusterRole
name: edit
apiGroup: rbac.authorization.k8s.io
---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
name: dev-view
namespace: paiement-prod
subjects:
- kind: Group
name: paiement-devs
apiGroup: rbac.authorization.k8s.io
roleRef:
kind: ClusterRole
name: view
apiGroup: rbac.authorization.k8s.io
Le motif à retenir : edit en staging, view en prod, et le passage en prod se fait par pipeline, pas par kubectl. Le groupement par groupe OIDC plutôt que par utilisateur individuel évite de réécrire le RBAC à chaque arrivée dans l'équipe. La documentation RBAC de Kubernetes reste la référence pour les verbes et les ressources autorisés.
Si tu ne veux pas gérer des groupes à la main, Kyverno peut générer le RoleBinding à partir d'une annotation sur le namespace. C'est plus souple, mais ça ajoute un contrôleur à maintenir : la documentation Kyverno couvre ce cas avec un generate policy.
Isolation réseau par défaut avec une NetworkPolicy
Le namespace cloisonne les noms, pas les paquets. Sans NetworkPolicy, un pod de staging peut joindre une base de données de production si le port est ouvert. Le deny par défaut est le seul point de départ défendable.
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: default-deny-ingress
namespace: paiement-staging
spec:
podSelector: {}
policyTypes:
- Ingress
Cette policy bloque tout le trafic entrant du namespace. Il faut ensuite autoriser explicitement l'ingress controller et les communications internes. C'est fastidieux, mais c'est le sens de la démarche : par défaut fermé, ouvert par exception documentée. Si ton ingress est Traefik, l'article sur la configuration de Traefik en 2026 donne les labels nécessaires côté service.
Nettoyer : détecter les namespaces orphelins
Un namespace qui n'a plus de déploiement actif continue de consommer des quotas, des IPs et de l'attention. Le script ci-dessous liste ceux dont le label managed-by vaut platform et qui n'ont reçu aucun événement depuis trente jours.
#!/usr/bin/env bash
set -euo pipefail
cutoff=$(date -d '30 days ago' +%s)
kubectl get ns -l managed-by=platform -o json \
| jq -r '.items[] | [.metadata.name, (.metadata.creationTimestamp)] | @tsv' \
| while IFS=$'\t' read -r ns created; do
created_ts=$(date -d "$created" +%s)
[ "$created_ts" -gt "$cutoff" ] && continue
pods=$(kubectl get pods -n "$ns" --no-headers 2>/dev/null | wc -l)
if [ "$pods" -eq 0 ]; then
echo "orphelin: $ns"
fi
done
Ce script ne supprime rien, il propose. C'est volontaire : la suppression d'un namespace efface tout ce qu'il contient, y compris les PVC. Fais tourner la détection en --dry-run pendant un mois avant d'automatiser le delete, et garde une liste d'exclusion explicite pour la production.
Les pièges qui coûtent une soirée
| Piège | Symptôme | Parade |
|---|---|---|
| Quota sans LimitRange | Les pods sans requests sont rejetés | Toujours déployer les deux ensemble |
| Namespace par branche de preview | 200 namespaces, quotas saturés | Un namespace partagé + suffixe de déploiement |
| Renommer un namespace | Impossible, l'objet est immuable | Créer/migrer/supprimer, jamais renommer |
| PVC après delete | Volumes orphelins facturés | Vérifier les PersistentVolumeClaim avant suppression |
| NetworkPolicy sans test | Le service « marche plus » | Tester l'ingress après chaque application |
Le cas du renommage mérite d'être martelé : kubectl n'a aucune commande rename, et le nom d'un namespace est immuable. Toute automatisation qui prétend le faire cache en réalité une recréation complète avec interruption de service.
Mettre le tout dans un seul pipeline
Une fois les manifests prêts, l'ordre d'application compte. Le namespace doit exister avant le quota, qui doit exister avant les déploiements. Un kubectl apply -f manifests/ sur un répertoire ne garantit pas cet ordre.
kubectl apply -f base/namespace.yaml
kubectl apply -f base/quota.yaml
kubectl apply -f base/limitrange.yaml
kubectl apply -f base/rbac.yaml
kubectl apply -f base/networkpolicy-default-deny.yaml
kubectl apply -k overlays/paiement-staging
Trois commandes suffisent à rendre le processus idempotent : un apply sur un namespace existant ne fait rien de destructeur. C'est cette propriété qui permet de rejouer le pipeline toutes les nuits sans crainte, et donc de détecter les dérives sans attendre l'incident.
Le corollaire : ne laisse personne appliquer des modifications manuelles sur ces objets. Un namespace modifié à la main sera réécrit à la prochaine exécution, et la personne qui a « juste ajouté une annotation » cherchera longtemps pourquoi elle a disparu.
FAQ
Un namespace par environnement ou par équipe ?
Par équipe et par environnement : paiement-staging, paiement-prod. Un namespace unique partagé entre environnements finit toujours par exposer la prod aux tests, et un namespace par microservice multiplie les quotas à maintenir.
Combien de namespaces un cluster supporte-t-il ?
Techniquement des milliers, mais chaque namespace ajoute des objets à surveiller et des policies à appliquer. Au-delà de cent, le coût de maintenance dépasse le bénéfice de l'isolation. Regroupe par domaine métier plutôt que par déploiement.
Faut-il un namespace par branche de preview ?
Non. Une centaine de branches ouvertes en parallèle génère autant de namespaces et sature les quotas. Préfère un namespace de preview partagé avec un suffixe de release dans le nom des déploiements, et une durée de vie explicite.
Comment migrer un namespace existant vers du code ?
Exporte-le en YAML avec kubectl get ns <nom> -o yaml, nettoie les champs gérés par le serveur (status, resourceVersion, uid), puis applique-le. Un kubectl diff avant l'apply montre les écarts entre l'existant et ta cible, sans rien modifier.
Et si un namespace est supprimé par erreur ?
Il reste en Terminating tant que des finalizers bloquent. La restauration passe par le redéploiement du pipeline sur un cluster où les données persistantes (PVC) ont survécu. D'où l'intérêt de séparer strictement le namespace stateless du stockage dans une classe de stockage dédiée.
Pour aller plus loin
La démarche complète tient dans un dépôt Git : une base Kustomize, un overlay par environnement, un pipeline qui applique dans l'ordre. Tu peux démarrer avec seulement le namespace et le quota, puis ajouter RBAC et NetworkPolicy quand la première équipe en aura besoin.
Les sources utiles pour creuser : la page officielle sur les namespaces Kubernetes, le tutoriel de création et d'administration, et le dépôt kubectx/kubens qui simplifie le changement de contexte au quotidien. Pour la partie configuration applicative, l'article sur les alternatives aux ConfigMaps complète bien le sujet.