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.

Automatiser les namespaces dans vos projets

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.

ObjetRôleOublié dans la nature
NamespaceLe contenant, ses labelsrarement
ResourceQuotaPlafond CPU/RAM/objets9 fois sur 10
LimitRangeValeurs par défaut des conteneurs9 fois sur 10
RoleBindingQui a le droit d'y touchersouvent remplacé par un cluster-admin
NetworkPolicyIsolation du trafic entrantpresque 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ègeSymptômeParade
Quota sans LimitRangeLes pods sans requests sont rejetésToujours déployer les deux ensemble
Namespace par branche de preview200 namespaces, quotas saturésUn namespace partagé + suffixe de déploiement
Renommer un namespaceImpossible, l'objet est immuableCréer/migrer/supprimer, jamais renommer
PVC après deleteVolumes orphelins facturésVérifier les PersistentVolumeClaim avant suppression
NetworkPolicy sans testLe 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.