Lab 07 : Sécurité, Quotas de Ressources & Isolement Réseau (NetworkPolicy)¶
Objectifs Pédagogiques :¶
- Protéger le cluster contre la surconsommation et l'effet « Noisy Neighbor » avec le couple ResourceQuota et LimitRange.
- Cloisonner le trafic réseau selon le modèle Zéro-Trust avec les NetworkPolicies : politique Default Deny, puis ouverture explicite des seuls flux légitimes (navigateur → frontend → backend → PostgreSQL).
- Durcir les conteneurs selon les standards de sécurité NSA/CISA avec les SecurityContext (interdiction du compte root, système de fichiers en lecture seule).
- Auditer les privilèges et déléguer des accès avec les ServiceAccounts et le modèle RBAC (
kubectl auth can-i). - Restreindre les accès à etcd (isolement réseau, TLS mutuel, droits sur les clés) et constater l'absence de chiffrement des Secrets au repos.
📌 Note Compatibilité OS :
Les commandes de cet atelier (kubectl apply,kubectl describe resourcequota,kubectl auth can-i,kubectl exec) sont rigoureusement identiques sous Windows (PowerShell), Linux (Ubuntu) et macOS (Terminal).💡 Modalités d'exécution (Au choix) :
* Option A (Recommandée - Confort DevOps Local) : Exécutez les commandes directement depuis votre machine locale avec votrekubectlet votrekubeconfig.
* Option B (Secours - PC d'entreprise verrouillé) : Connectez-vous en SSH surk8s-control: l'outillage et les manifests sont pré-installés dans~/labs/.🗂️ Namespace de travail :
campus-dev. Ce lab est indépendant des autres : son étape 0 recréecampus-devà neuf et y installe tout ce dont il a besoin. Vous pouvez le réaliser sans avoir fait les labs précédents, ou le recommencer à tout moment.
Contexte Métier¶
En environnement partagé ou de production réglementée (secteur bancaire, assurance, santé), laisser un conteneur consommer toute la mémoire d'un nœud physique ou permettre à n'importe quel conteneur compromis d'accéder directement au port 5432 de la base de données PostgreSQL constitue une faille critique de sécurité. Cet atelier vous guide pour verrouiller les ressources système, cloisonner le réseau et durcir les conteneurs au niveau du noyau Linux.
Étape 0 : Préparer l'environnement¶
Le dossier starter/ du lab installe l'application complète dans l'état de fin du Lab 06 :
| Fichier | Contenu |
|---|---|
01-config.yaml |
Le ConfigMap campus-config (paramètres non sensibles de l'API). |
02-postgres.yaml |
Le PVC pvc-postgres, la base PostgreSQL persistante et son Service postgres. |
03-backend.yaml |
L'API campus-backend (2 réplicas, ConfigMap, Secret et sondes de santé, sans securityContext ni ressources : ce lab les ajoute) et son Service campus-backend. |
04-frontend.yaml |
Le frontend et son Service NodePort campus-frontend-svc (port 30088). |
Les identifiants de la base ne sont pas versionnés dans le starter : vous créez le Secret campus-db-credentials par une commande, comme au Lab 05.
Repartez d'un namespace campus-dev vide, puis appliquez le starter. Depuis la racine du dépôt (Option A) ou depuis ~ sur k8s-control (Option B : mettez d'abord le dépôt à jour avec git -C ~/formation pull, puis remplacez labs/ par ~/labs/) :
kubectl delete namespace campus-dev --ignore-not-found # ⚠️ supprime tout le contenu de campus-dev
kubectl create namespace campus-dev
kubectl config set-context --current --namespace=campus-dev
kubectl create secret generic campus-db-credentials --from-literal=POSTGRES_DB=campus --from-literal=POSTGRES_USER=campus --from-literal='POSTGRES_PASSWORD=CampusSecret2026!'
kubectl apply -f labs/07-securite-quotas/starter/
kubectl rollout status deployment/campus-postgres --timeout=180s
kubectl rollout status deployment/campus-backend --timeout=300s
La suppression du namespace peut prendre jusqu'à une minute. Spring Boot met ensuite 20 secondes à 2 minutes à démarrer.
Exercice 1 : Gouvernance des Ressources avec LimitRange & ResourceQuota¶
En entreprise, un ResourceQuota seul crée un piège fréquent : dès qu'un quota de CPU/RAM est actif sur un namespace, tout pod créé sans spécification explicite de requests et limits est immédiatement rejeté par l'API Server ! C'est pourquoi on configure toujours un LimitRange en amont.
1. Configurer un LimitRange pour injecter des valeurs par défaut¶
Créez le fichier campus-limitrange.yaml qui attribue automatiquement des limites aux conteneurs qui n'en déclarent pas :
apiVersion: v1
kind: LimitRange
metadata:
name: campus-default-limits
spec:
limits:
- default:
cpu: "500m"
memory: "512Mi"
defaultRequest:
cpu: "100m"
memory: "128Mi"
type: Container
Appliquez le LimitRange :
2. Définir le plafond global avec un ResourceQuota¶
Créez le fichier campus-quota.yaml pour plafonner l'utilisation globale cumulée du namespace :
* Maximum 10 Pods au total
* Maximum 2 cœurs CPU (requests)
* Maximum 2 Go de RAM (requests)
* Maximum 4 cœurs CPU (limits)
* Maximum 4 Go de RAM (limits)
apiVersion: v1
kind: ResourceQuota
metadata:
name: campus-compute-quota
spec:
hard:
pods: "10"
requests.cpu: "2"
requests.memory: 2Gi
limits.cpu: "4"
limits.memory: 4Gi
💡 Pourquoi 10 pods ? Votre namespace en compte déjà 5 (2 backend, 2 frontend, 1 base). Une mise à jour progressive avec
maxSurge: 1a besoin d'une place libre pour le pod supplémentaire, et vos pods de test aussi. Un quota trop serré bloquerait silencieusement les déploiements : dimensionnez toujours un quota en tenant compte des rolling updates.
Appliquez le ResourceQuota et visualisez la consommation en direct :
3. Test de rejet par l'Admission Controller¶
Tentez de déployer un pod sollicitant 5 cœurs CPU (dépassant le plafond autorisé de 4 cœurs) :
cat << 'EOF' | kubectl apply -f -
apiVersion: v1
kind: Pod
metadata:
name: pod-trop-gros
spec:
containers:
- name: sleeper
image: busybox:1.36
command: ["sleep", "3600"]
resources:
requests:
cpu: "5"
limits:
cpu: "5"
EOF
Observez l'erreur immédiate renvoyée par l'API Server :
Error from server (Forbidden): error when creating "STDIN": pods "pod-trop-gros" is forbidden: exceeded quota: campus-compute-quota, requested: limits.cpu=5,requests.cpu=5, used: ...
Le cluster a automatiquement protégé ses ressources physiques !
Exercice 2 : Cloisonnement Réseau Zéro-Trust avec NetworkPolicy¶
Par défaut dans Kubernetes, le réseau est entièrement plat : n'importe quel pod du cluster peut contacter le port 5432 de PostgreSQL, même un pod web compromis ou un script tiers.
1. État des lieux : un réseau entièrement ouvert¶
Vérifiez qu'un pod quelconque, sans aucun label, peut joindre PostgreSQL. Nous utilisons l'image postgres:16-alpine, déjà présente sur les nœuds, pour son outil de test pg_isready :
kubectl run rogue-pod --image=postgres:16-alpine --rm -i --restart=Never -- pg_isready -h postgres -p 5432 -t 3
postgres:5432 - accepting connections. N'importe quel conteneur compromis du cluster pourrait attaquer la base.
2. Règle d'or Zéro-Trust : Isoler par défaut (Default Deny Ingress)¶
Créez le fichier default-deny-ingress.yaml, qui coupe tout le trafic entrant vers tous les pods du namespace (podSelector: {}) :
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: default-deny-ingress
spec:
podSelector: {}
policyTypes:
- Ingress
⚠️ Note sur le plugin CNI : Les
NetworkPoliciesnécessitent un pilote réseau (CNI) compatible (Calico, Cilium, Weave, ou Kube-Router). Sur votre cluster AWS Kubeadm, Calico a été déployé au Lab 00 et applique nativement les NetworkPolicies.
Constatez les effets, puis rechargez le portail dans votre navigateur (http://<IP_PUBLIQUE_WORKER>:30088) :
kubectl run rogue-pod --image=postgres:16-alpine --rm -i --restart=Never -- pg_isready -h postgres -p 5432 -t 3
no response), mais le portail est également devenu inaccessible : plus rien n'entre dans aucun pod du namespace. Le modèle Zéro-Trust impose maintenant d'autoriser explicitement chaque flux légitime.
💡 Les sondes
livenessetreadinesscontinuent de fonctionner : le trafic provenant du nœud qui héberge le pod (celui dukubelet) est toujours autorisé par les NetworkPolicies.
3. Ouvrir les trois flux légitimes du Campus Summer Portal¶
flowchart LR
Web["Navigateur<br/>(NodePort 30088)"] -->|"TCP 8080 ✅"| FE["campus-frontend"]
FE -->|"TCP 8080 ✅"| BE["campus-backend"]
BE -->|"TCP 5432 ✅"| DB["campus-postgres"]
Rogue["Pod non autorisé"] -.->|"❌ bloqué"| DB
Rogue -.->|"❌ bloqué"| BE
Créez le fichier campus-networkpolicies.yaml, qui contient les trois règles :
# Flux 1 : le navigateur (via le NodePort) vers le frontend, sur son port 8080
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: allow-web-to-frontend
spec:
podSelector:
matchLabels:
app: campus-frontend
policyTypes:
- Ingress
ingress:
- ports:
- protocol: TCP
port: 8080
---
# Flux 2 : uniquement le frontend vers l'API backend
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: allow-frontend-to-backend
spec:
podSelector:
matchLabels:
app: campus-backend
policyTypes:
- Ingress
ingress:
- from:
- podSelector:
matchLabels:
app: campus-frontend
ports:
- protocol: TCP
port: 8080
---
# Flux 3 : uniquement le backend vers PostgreSQL
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: allow-only-backend-to-postgres
spec:
podSelector:
matchLabels:
app: campus-postgres
policyTypes:
- Ingress
ingress:
- from:
- podSelector:
matchLabels:
app: campus-backend
ports:
- protocol: TCP
port: 5432
💡 Une règle
ingresssans champfrom(flux 1) accepte toutes les sources, mais seulement sur le port indiqué. C'est nécessaire pour le NodePort : le trafic arrive des nœuds, avec des adresses sources variables.
Appliquez les règles :
4. Test d'intrusion : Tentative d'accès pirate non autorisée¶
Relancez le conteneur pirate, sans le label app=campus-backend :
kubectl run rogue-pod --image=postgres:16-alpine --rm -i --restart=Never -- pg_isready -h postgres -p 5432 -t 3
Résultat attendu : postgres:5432 - no response. Le paquet est rejeté par le filtre réseau du noyau, programmé par Calico !
5. Validation des flux légitimes¶
-
Un conteneur de test portant l'étiquette autorisée
app=campus-backendatteint la base :Résultat attendu :kubectl run test-auth --image=postgres:16-alpine --labels='app=campus-backend' --rm -i --restart=Never -- pg_isready -h postgres -p 5432 -t 3postgres:5432 - accepting connections. L'accès est accordé exclusivement au microservice habilité. -
Rechargez le portail dans votre navigateur : il fonctionne de nouveau, données comprises. Vérifiez aussi la chaîne complète en ligne de commande, à travers le frontend :
La réponse contient"status":"UP"et l'état de la base : navigateur → frontend → backend → PostgreSQL, chaque flux est explicitement autorisé.
💡 Indice : le portail reste inaccessible après l'application des règles
* Vérifiez les labels de vos pods : `kubectl get pods --show-labels`. Les règles reposent sur `app=campus-frontend`, `app=campus-backend` et `app=campus-postgres`. * Listez les règles actives et leur cible : `kubectl describe networkpolicy`.⚠️ Attention, le pod
test-authprouve aussi une faiblesse : n'importe qui peut poser un label. Une NetworkPolicy fondée sur les labels n'est solide que si les droits de créer des pods sont eux-mêmes restreints, ce que permet le RBAC (exercice 4).
Exercice 3 : Durcissement des Conteneurs avec SecurityContext¶
Selon le guide de durcissement Kubernetes de la NSA et de la CISA, un conteneur de production ne doit jamais s'exécuter en tant qu'utilisateur root (UID 0), ne doit jamais pouvoir élever ses privilèges et doit idéalement monter son disque racine en lecture seule (Read-only root filesystem).
1. Intégrer les directives de sécurité au déploiement Backend¶
Créez le fichier deployment-backend.yaml en partant de starter/03-backend.yaml (partie Deployment) et complétez-le avec un bloc securityContext au niveau du pod et du conteneur, ainsi que des ressources explicites (sans elles, le LimitRange de l'exercice 1 imposerait ses valeurs par défaut) :
apiVersion: apps/v1
kind: Deployment
metadata:
name: campus-backend
spec:
replicas: 2
strategy:
type: RollingUpdate
rollingUpdate:
maxSurge: 1
maxUnavailable: 0
selector:
matchLabels:
app: campus-backend
template:
metadata:
labels:
app: campus-backend
spec:
affinity:
podAntiAffinity:
preferredDuringSchedulingIgnoredDuringExecution:
- weight: 100
podAffinityTerm:
topologyKey: kubernetes.io/hostname
labelSelector:
matchLabels:
app: campus-backend
securityContext:
runAsNonRoot: true
runAsUser: 10001
runAsGroup: 10001
fsGroup: 10001
containers:
- name: campus-backend
image: regaieg/campus:backend-1.0.0
ports:
- containerPort: 8080
securityContext:
allowPrivilegeEscalation: false
readOnlyRootFilesystem: false
capabilities:
drop:
- ALL
resources:
requests:
cpu: 150m
memory: 256Mi
limits:
cpu: 500m
memory: 512Mi
startupProbe:
httpGet:
path: /actuator/health/liveness
port: 8080
periodSeconds: 5
failureThreshold: 36
readinessProbe:
httpGet:
path: /actuator/health
port: 8080
periodSeconds: 5
failureThreshold: 3
livenessProbe:
httpGet:
path: /actuator/health/liveness
port: 8080
periodSeconds: 10
failureThreshold: 3
envFrom:
- configMapRef:
name: campus-config
env:
- name: SPRING_DATASOURCE_URL
value: "jdbc:postgresql://postgres:5432/campus"
- name: SPRING_DATASOURCE_USERNAME
valueFrom:
secretKeyRef:
name: campus-db-credentials
key: POSTGRES_USER
- name: SPRING_DATASOURCE_PASSWORD
valueFrom:
secretKeyRef:
name: campus-db-credentials
key: POSTGRES_PASSWORD
💡 Pourquoi
readOnlyRootFilesystem: false? Spring Boot écrit des fichiers temporaires dans/tmp. Passer le système de fichiers en lecture seule exigerait de monter un volumeemptyDirsur/tmp: c'est le niveau de durcissement suivant, à mettre en œuvre en production.
Appliquez le déploiement durci :
2. Vérifier l'identité système du processus dans le conteneur¶
Vérifiez l'UID sous lequel tourne le conteneur :
Vous constatez : uid=10001(10001) gid=10001(10001) groups=10001(10001). Le processus ne possède aucun droit d'administration sur le système hôte ! Les messages id: cannot find name for user ID 10001 sont normaux : cet UID n'est pas déclaré dans le fichier /etc/passwd de l'image, ce qui n'empêche pas le processus de tourner.
Exercice 4 : Audit RBAC & ServiceAccount Dédié¶
Par défaut, chaque pod reçoit un jeton d'authentification lié au compte de service nommé default de son namespace (ici system:serviceaccount:campus-dev:default). Si ce jeton est compromis, un attaquant pourrait interroger l'API Kubernetes.
1. Tester les autorisations avec kubectl auth can-i¶
La commande kubectl auth can-i est l'outil indispensable de l'administrateur pour vérifier instantanément les droits d'un utilisateur ou d'un compte de service :
# Vérifier ce que vous avez le droit de faire
kubectl auth can-i create pods
kubectl auth can-i delete namespaces
kubectl auth can-i create clusterroles
# Vérifier les droits du compte de service par défaut
kubectl auth can-i list secrets --as=system:serviceaccount:campus-dev:default
no : le compte de service applicatif standard n'a pas le droit d'énumérer les secrets du cluster.
2. Créer un ServiceAccount restreint pour une tâche d'automatisation¶
Créez un compte de service dédié nommé campus-ci-runner et associez-lui un rôle en lecture seule :
kubectl create serviceaccount campus-ci-runner
kubectl create role pod-reader --verb=get,list,watch --resource=pods
kubectl create rolebinding read-pods --role=pod-reader --serviceaccount=campus-dev:campus-ci-runner
Validez les droits accordés :
kubectl auth can-i list pods --as=system:serviceaccount:campus-dev:campus-ci-runner
kubectl auth can-i delete pods --as=system:serviceaccount:campus-dev:campus-ci-runner
yes, le second retourne no ! Votre délégation RBAC est parfaitement étanche.
Exercice 5 : Restreindre les Accès à etcd et à l'API Server¶
etcd contient l'intégralité de l'état du cluster, y compris tous les Secrets. Quiconque peut lire etcd directement contourne totalement le RBAC de l'API Server. Sa protection repose sur 4 verrous : le réseau, l'authentification mutuelle TLS, les droits sur les fichiers de clés et le chiffrement des données au repos.
📌 Modalité : cet exercice s'exécute sur
k8s-controlen SSH (Option B), car il inspecte les fichiers du plan de contrôle. Il n'est pas réalisable sur KillerCoda ni sur Minikube de manière fiable.
1. Verrou réseau : qui peut joindre le port 2379 ?¶
-
Repérez les adresses d'écoute d'
etcd:sudo ss -tlnp | grep -E ':2379|:2380' sudo grep -E 'listen-client-urls|listen-peer-urls' /etc/kubernetes/manifests/etcd.yamletcdécoute sur127.0.0.1et sur l'IP privée du nœud, jamais sur l'IP publique. -
Ouvrez
labs/00-provisioning-cluster/terraform/main.tfet relisez les règlesingressdu Security Group : seuls les ports22,6443et30000-32767sont ouverts sur Internet. Le port2379n'est joignable que depuis les nœuds du cluster (règleself = true).
💡 Indice 1 : Et le port 6443 ouvert à 0.0.0.0/0 ?
C'est un compromis de formation pour que chacun puisse utiliser `kubectl` depuis son poste. En production, l'API Server n'est exposé qu'aux plages d'adresses d'administration (VPN, bastion) ou via un endpoint privé. C'est le premier des « points à sécuriser » : **l'accès à l'API Kubernetes**.2. Verrou TLS mutuel : sans certificat client, pas de dialogue¶
-
Vérifiez qu'
etcdexige un certificat client signé par sa propre autorité : -
Tentez une connexion sans certificat client :
La négociation TLS échoue :etcdrefuse tout client qui ne présente pas de certificat valide. -
Identifiez le seul client légitime d'
etcd, l'API Server, et les certificats qu'il utilise :
3. Verrou système : les clés privées sont réservées à root¶
Les fichiers .key sont en mode 600 et appartiennent à root. C'est pourquoi toute commande etcdctl doit être préfixée par sudo : un accès SSH non privilégié au nœud ne suffit pas pour lire etcd.
4. Verrou des données : vos Secrets sont-ils chiffrés dans etcd ?¶
-
Créez un secret de test, puis lisez-le directement dans
etcd, sans passer par l'API :La sortiekubectl create secret generic test-etcd --from-literal=motdepasse=SuperSecret2026 sudo ETCDCTL_API=3 etcdctl \ --endpoints=https://127.0.0.1:2379 \ --cacert=/etc/kubernetes/pki/etcd/ca.crt \ --cert=/etc/kubernetes/pki/etcd/server.crt \ --key=/etc/kubernetes/pki/etcd/server.key \ get /registry/secrets/campus-dev/test-etcd | grep -a -o "motdepasse.*SuperSecret2026"motdepasseSuperSecret2026montre la clé et la valeur en clair (grep -atraite le contenu binaire comme du texte) : par défaut, Kubeadm ne chiffre pas les Secrets au repos. L'encodage base64 vu au Lab 05 n'est pas un chiffrement. -
Supprimez le secret de test :
💡 Indice 2 : Comment chiffrer les Secrets au repos ?
On fournit à l'API Server un fichier `EncryptionConfiguration` via l'option `--encryption-provider-config` : Les nouveaux Secrets sont alors chiffrés avant d'être écrits dans `etcd` ; les anciens doivent être réécrits (`kubectl get secrets -A -o json | kubectl replace -f -`). En production, on préfère un fournisseur **KMS** (AWS KMS, Google Cloud KMS, Azure Key Vault) pour que la clé ne soit jamais stockée sur le nœud. Cette manipulation redémarre l'API Server : elle est démontrée par le formateur et non réalisée par chaque stagiaire.5. Synthèse : les points à sécuriser¶
| Point à sécuriser | Mesure vue dans cet atelier |
|---|---|
| Accès à l'API Kubernetes | RBAC + ServiceAccounts dédiés (Ex. 4), exposition réseau du port 6443 |
| Limitation des ressources | LimitRange + ResourceQuota (Ex. 1) |
| Contrôle des accès réseau | NetworkPolicy Default Deny (Ex. 2) |
| Durcissement des conteneurs | securityContext non-root (Ex. 3) |
Restriction des accès à etcd |
Isolement réseau, TLS mutuel, droits root, chiffrement au repos (Ex. 5) |
Critères de Validation (Checklist)¶
- Le couple
LimitRangeetResourceQuotaprotège le cluster contre l'épuisement des CPU/RAM. - La tentative de déploiement dépassant les quotas a été formellement rejetée par l'API Server.
- La politique
default-deny-ingressest active et seuls les trois flux légitimes sont ouverts. - Le trafic pirate vers le port
5432de PostgreSQL est bloqué, et le portail fonctionne toujours de bout en bout. - Le conteneur s'exécute avec l'UID
10001sans privilèges root (runAsNonRoot: true). - Vous savez auditer et déléguer des privilèges RBAC avec
kubectl auth can-i. - Vous avez vérifié qu'
etcdrefuse tout client sans certificat et n'est pas exposé sur Internet. - Vous avez constaté qu'un Secret est lisible en clair dans
etcdet connaissez la parade (EncryptionConfiguration/ KMS).