Un déni de service dans un cluster Kubernetes n'a pas besoin d'un attaquant sophistiqué : une application compromise, ou simplement mal écrite, qui n'a aucune limite peut prendre tout le processeur ou toute la mémoire d'un nœud, et priver les autres applications de ressources. Cette leçon montre ce qu'un déni de service épuise, comment lire ses symptômes, comment plafonner un namespace pour que la charge reste dans son périmètre, et comment vérifier qu'une application d'un autre namespace continue de répondre. Elle s'adresse à celui qui connaît déjà les requests, les limits et les quotas, et prépare l'objectif « Denial of Service » du domaine « Kubernetes Threat Model » de la certification KCSA.
Ce que vous allez apprendre
Section intitulée « Ce que vous allez apprendre »- Décrire ce qu'un déni de service épuise dans un cluster.
- Provoquer et lire une pression processeur, et reconnaître les symptômes d'une charge mémoire (Pods évincés, conteneur arrêté pour mémoire, nœud sous pression), que la démonstration ne provoque pas.
- Plafonner un namespace avec un ResourceQuota et un LimitRange, et vérifier qu'une création hors quota est refusée.
- Déclarer requests et limits sur un conteneur et dire ce qui arrive quand il dépasse sa limite.
- Nommer les composants du plan de contrôle qu'un déni de service peut viser.
- Vérifier qu'une application d'un autre namespace répond pendant la charge.
- Détecter une persistance laissée par un attaquant et la retirer sans abîmer l'application, avec le challenge du module.
Prérequis
Section intitulée « Prérequis »- Avoir suivi la leçon Persistance : ce qu'un attaquant laisse derrière lui, car le challenge de fin de module combine les deux.
- Connaître requests et limits : ce que garantit une request, ce qu'arrête une limit, et les classes de QoS. Cette leçon ne les réexplique pas.
- Connaître les ResourceQuota et LimitRange : cette leçon les emploie du côté défensif et renvoie à leur leçon pour le détail de chaque champ.
- Savoir ce qu'est un namespace.
Qu'est-ce qu'un déni de service dans un cluster ?
Section intitulée « Qu'est-ce qu'un déni de service dans un cluster ? »Un déni de service épuise une ressource partagée jusqu'à ce que d'autres charges ne puissent plus s'en servir. Dans la méthode STRIDE de la leçon Frontières de confiance, c'est la lettre D. Ici, la ressource partagée est le cluster lui-même. Le tableau liste ce qui peut être épuisé, ce qu'on observe, et le contrôle qui s'y oppose.
| Ressource visée | Ce qu'on observe | Contrôle |
|---|---|---|
| Processeur d'un nœud | Les Pods qui ne déclarent pas de requests ralentissent | requests.cpu et limits.cpu sur chaque conteneur, quota de processeur du namespace |
| Mémoire d'un nœud | Conteneur arrêté pour mémoire, Pods évincés, nœud sous pression | limits.memory, quota de mémoire du namespace |
| Processus d'un nœud (PID) | Une fork bomb remplit la table des processus, le nœud passe en condition PIDPressure | Limite de processus par Pod du kubelet (podPidsLimit) |
| Disque local d'un nœud | Journaux ou fichiers temporaires remplissent le disque, condition DiskPressure, Pods évincés | Quota limits.ephemeral-storage du namespace |
| Capacité réservable | Une charge qui déclare des requests très élevées épuise ce que le planificateur peut réserver, et les nouveaux Pods restent Pending | Quotas requests.cpu et requests.memory du namespace |
| Nombre de Pods | Le planificateur ne trouve plus de place ; un nœud accepte 110 Pods par défaut | Quota pods du namespace |
| Nombre d'objets | etcd grossit, le plan de contrôle ralentit | Quotas d'objets count/... |
| Requêtes vers l'API server | Les commandes kubectl et les contrôleurs répondent lentement | API Priority and Fairness borne le volume de requêtes, RBAC limite leur coût |
| Stockage | Volumes saturés, etcd plein | Quota requests.storage, surveillance d'etcd |
Ce tableau mélange deux terrains. Le processeur, la mémoire, les processus, le disque et le nombre de Pods se jouent sur les nœuds et dans le namespace de l'attaquant : on les traite avec des plafonds. Le nombre d'objets et les requêtes vers l'API server touchent le plan de contrôle, partagé par tout le cluster, qu'un plafond par namespace ne protège qu'en partie. Le stockage touche les deux. Cette leçon démontre la pression sur le processeur et le plafonnement par quota ; les autres lignes se lisent dans le tableau, sans manipulation.
Que provoque une charge sans limites ?
Section intitulée « Que provoque une charge sans limites ? »Une charge sans limites prend ce qu'elle peut sur son nœud, mais tous les voisins ne subissent pas la même chose. Le processeur est partagé au prorata des requests : un voisin qui déclare ses requests garde sa part, même quand la charge tourne en boucle. Un Pod sans requests (classe de QoS BestEffort) reçoit un poids minimal, et c'est lui qui ralentit.
Le symptôme dépend ensuite de la ressource. Un conteneur qui dépasse sa limite de mémoire est arrêté par le noyau. Un conteneur qui dépasse sa limite de processeur est ralenti. Un conteneur sans limite de processeur peut prendre les cœurs que les autres ne réservent pas. Quand la mémoire du nœud manque, c'est le kubelet qui évince des Pods, en commençant par ceux dont l'usage dépasse leurs requests : un Pod gourmand de classe BestEffort fait donc partie des premiers candidats, la priorité des Pods départageant ensuite.
L'attaque a un second visage : une charge qui déclare des requests très élevées réserve la capacité du nœud sans forcément la consommer. Le planificateur n'a alors plus de place, et les nouveaux Pods des autres applications restent Pending. Le nombre de Pods et d'objets créés pèse aussi sur le plan de contrôle (etcd, API server), même quand les Pods ne font rien.
Pour voir ces symptômes sans risque, lancez une charge dans un namespace de test, jamais sur un cluster qui sert des utilisateurs. Le manifeste suivant déploie quatre Pods qui font tourner une boucle sans fin, donc qui consomment un cœur chacun, et ne déclarent aucune ressource. Dans l'exemple, la charge vit dans le namespace essai-charge et une autre application, l'annuaire, dans espace-annuaire : c'est un service web quelconque, déployé avec un Service du même nom, que le lab de cette leçon fournit déjà.
apiVersion: apps/v1kind: Deploymentmetadata: name: charge-gourmande namespace: essai-chargespec: replicas: 4 selector: matchLabels: app: charge-gourmande template: metadata: labels: app: charge-gourmande spec: containers: - name: boucle image: busybox:1.38.0@sha256:a46257e06c82ad85242d0d38077d0a52d9896389ca60a1a59d3463db586e5fa4 command: ["sh", "-c", "while true; do :; done"]Créez le namespace avec kubectl create namespace essai-charge, appliquez le manifeste, puis mesurez la pression. Les commandes ci-dessous supposent que le metrics-server est installé : sans lui, kubectl top échoue.
kubectl top nodeskubectl top pods -n essai-charge --sort-by=cpukubectl describe node | grep -A 8 'Conditions:'Regardez d'abord la colonne CPU% ou MEMORY% de kubectl top nodes : un nœud proche de 100 % est saturé. La deuxième commande classe ensuite les Pods par consommation et désigne le coupable. Cette charge ne consomme que du processeur : vous voyez CPU% monter, mais aucune éviction. Les voisins qui déclarent leurs requests gardent leur part de processeur, et ceux qui n'en déclarent pas peuvent ralentir. L'annuaire est donc touché ou non selon ses propres requests.
Les symptômes liés à la mémoire (OOMKilled, Evicted, MemoryPressure) se lisent avec les mêmes commandes, mais seulement sur une charge qui alloue de la mémoire. Cette leçon n'en fournit pas le manifeste. Dans la sortie de describe node, la ligne MemoryPressure passe à True quand le kubelet manque de mémoire et commence à évincer, et les Pods évincés restent alors visibles avec le statut Failed :
kubectl get pods -A --field-selector=status.phase=Failedkubectl get events -A --sort-by=.metadata.creationTimestampUn Pod évincé porte la raison Evicted dans son statut. Un conteneur arrêté pour mémoire se lit autrement, dans kubectl describe pod : la section Last State indique OOMKilled avec le code de sortie 137. Ces deux symptômes ont deux causes différentes : OOMKilled frappe le conteneur qui a dépassé sa propre limite, Evicted frappe un Pod parce que le nœud entier manque de mémoire. La leçon Requests et Limits provoque un OOMKilled pas à pas.
Comment plafonner un namespace ?
Section intitulée « Comment plafonner un namespace ? »Pour plafonner un namespace, on pose deux objets ensemble : un ResourceQuota qui limite le total du namespace, et un LimitRange qui donne des valeurs par défaut aux conteneurs qui n'en déclarent pas. Les deux sont nécessaires. Sans LimitRange, un quota sur le processeur et la mémoire refuse tout Pod dont les conteneurs ne déclarent ni requests ni limits, et vous bloquez les applications légitimes qui n'ont rien déclaré. Avec lui, elles reçoivent des valeurs par défaut.
Le manifeste suivant plafonne essai-charge à 500 millicœurs et 512 Mio de mémoire demandés, avec 5 Pods au plus, et fournit des valeurs par défaut. Les champs sont ceux de la leçon ResourceQuota et LimitRange, à laquelle il faut se reporter pour leur détail.
apiVersion: v1kind: ResourceQuotametadata: name: plafond namespace: essai-chargespec: hard: pods: "5" requests.cpu: 500m requests.memory: 512Mi limits.cpu: "1" limits.memory: 1Gi---apiVersion: v1kind: LimitRangemetadata: name: valeurs-par-defaut namespace: essai-chargespec: limits: - type: Container defaultRequest: cpu: 100m memory: 64Mi default: cpu: 200m memory: 128MiAvec ces plafonds, les Pods créés à partir de maintenant ne peuvent pas dépasser un cœur de limite au total, même si la charge demande plus de réplicas. Appliquez le manifeste avec kubectl apply -f plafond.yaml, puis lisez l'état du quota :
kubectl describe resourcequota plafond -n essai-chargeLa colonne Used s'affiche à côté de Hard pour chaque ressource. Elle part de zéro si le namespace est vide, ou compte ce qui tourne déjà.
Pourquoi la charge déjà en marche n'est-elle pas bornée ?
Section intitulée « Pourquoi la charge déjà en marche n'est-elle pas bornée ? »Un ResourceQuota et un LimitRange ne s'appliquent qu'aux Pods créés après eux. Ils ne modifient pas les Pods en marche : une charge lancée avant le plafond continue de tourner sans limites, et c'est le piège de cette leçon. Pour la borner, il faut recréer ses Pods : supprimés, ils sont relancés par leur ReplicaSet, et les nouveaux reçoivent alors les valeurs par défaut.
kubectl delete pods -l app=charge-gourmande -n essai-chargekubectl get pods -n essai-charge \ -o custom-columns=NOM:.metadata.name,CPU_LIMIT:.spec.containers[0].resources.limits.cpuLa colonne CPU_LIMIT doit afficher 200m pour chaque nouveau Pod. Si elle est vide, le Pod a été créé avant le LimitRange.
Pendant quelques dizaines de secondes, les anciens Pods peuvent rester en Terminating : le sh qui tourne en PID 1 n'écoute pas SIGTERM, et Kubernetes attend le délai de grâce de 30 secondes par défaut avant de les tuer. Ils comptent encore dans le quota, donc vous pouvez voir passer exceeded quota et moins de Pods que prévu, le temps qu'ils disparaissent.
Ces valeurs par défaut sont un filet de sécurité, pas une réponse : chaque manifeste déclare ses propres requests et limits, avec des valeurs choisies pour l'application. Pour charge-gourmande, le bloc suivant se place sous le conteneur boucle. Un conteneur qui dépasse sa limite de mémoire est alors arrêté par le noyau, et un conteneur qui dépasse sa limite de processeur est ralenti.
resources: requests: cpu: 100m memory: 64Mi limits: cpu: 200m memory: 128MiUn Deployment qui demande plus de Pods que le quota n'en autorise ne reçoit pas de refus à sa création : c'est son ReplicaSet qui échoue à créer les Pods en trop, et le message exceeded quota apparaît dans les événements du namespace (kubectl get events -n essai-charge) et dans kubectl describe replicaset. Un Pod créé directement est, lui, refusé tout de suite. Le Pod d'essai ci-dessous demande 2 cœurs, soit quatre fois le plafond de requests.cpu :
kubectl apply -n essai-charge -f - <<'EOF'apiVersion: v1kind: Podmetadata: name: trop-grosspec: containers: - name: attente image: busybox:1.38.0@sha256:a46257e06c82ad85242d0d38077d0a52d9896389ca60a1a59d3463db586e5fa4 command: ["sleep", "3600"] resources: requests: cpu: "2" memory: 64Mi limits: cpu: "2" memory: 128MiEOFLe serveur répond par une erreur Forbidden qui contient exceeded quota: plafond, avec les valeurs demandée, utilisée et limite. C'est la preuve que le plafond est actif : on la lit sur une tentative réelle de création, pas sur la lecture du manifeste du quota.
Quels composants du plan de contrôle un déni de service peut-il viser ?
Section intitulée « Quels composants du plan de contrôle un déni de service peut-il viser ? »Un déni de service peut viser le plan de contrôle plutôt que les nœuds, et deux composants sont exposés : l'API server et etcd. L'API server reçoit toutes les requêtes du cluster, celles des humains comme celles des contrôleurs. Un compte compromis qui l'inonde de requêtes, par exemple en listant en boucle tous les objets, peut ralentir tout le cluster. etcd stocke chaque objet : créer des milliers d'objets, même vides, le fait grossir jusqu'à son quota de stockage (2 Gio par défaut), après quoi il n'accepte plus d'écriture, comme le détaille la leçon etcd.
Trois contrôles limitent ces attaques, chacun sur un point différent.
API Priority and Fairness borne le volume de requêtes : l'API server les range dans des files et des niveaux de priorité, pour qu'une source bruyante ne prive pas les autres. C'est un réglage du plan de contrôle, que le fournisseur gère sur un cluster managé.
Le RBAC limite leur coût. Une requête refusée est quand même reçue et traitée, mais un compte sans le droit de lister tous les Secrets ou de créer en masse ne peut pas déclencher les requêtes les plus lourdes. La leçon RBAC l'enseigne.
Le quota d'objets plafonne ce qu'un namespace peut créer. count/configmaps, count/secrets ou count/pods dans un ResourceQuota bornent le nombre d'objets, donc la taille qu'il peut donner à etcd.
Comment vérifier qu'une autre application continue de répondre ?
Section intitulée « Comment vérifier qu'une autre application continue de répondre ? »Pour vérifier l'isolation, appelez une application d'un autre namespace pendant que la charge tourne. L'isolation n'est prouvée que par un appel réel : lire que le quota est posé ne dit pas que l'annuaire répond. La commande suivante lance un Pod temporaire dans le namespace de l'annuaire et l'interroge par son nom de service.
kubectl get deployment annuaire -n espace-annuairekubectl run sonde -n espace-annuaire --rm -i --restart=Never \ --image=busybox:1.38.0@sha256:a46257e06c82ad85242d0d38077d0a52d9896389ca60a1a59d3463db586e5fa4 \ -- wget -qO- -T 3 http://annuaireLa première commande doit montrer tous les réplicas prêts. La seconde doit afficher la réponse de l'application. Si le délai de 3 secondes expire, l'annuaire ne répond plus : la charge a pris trop de ressources sur son nœud, ou une NetworkPolicy bloque la sonde. Ce que le quota garantit, c'est qu'une charge dont les Pods sont créés après lui ne peut plus réserver ni créer au-delà du plafond : elle ne dépasse pas un cœur de limite au total, ni 5 Pods. Si l'annuaire ralentit malgré tout, regardez ses propres requests : sans requests, il reste le premier à pâtir d'un voisin qui consomme le nœud.
Quand vous avez fini, supprimez le namespace de test avec kubectl delete namespace essai-charge : les quatre Pods qui tournent en boucle partent avec lui.
Quelles erreurs éviter ?
Section intitulée « Quelles erreurs éviter ? »Trois erreurs reviennent.
- Poser le quota sans LimitRange. Les Pods sans requests ni limits sont alors refusés, et l'on bloque les applications légitimes au lieu de la charge abusive.
- Croire que le quota protège les Pods déjà lancés. Il ne s'applique qu'aux créations suivantes.
- Plafonner les nœuds et oublier le plan de contrôle. Un compte qui peut créer des objets sans limite menace etcd, quel que soit le plafond de processeur.
Mettre en pratique
Section intitulée « Mettre en pratique »Le premier lab est guidé. Une charge sans limites tourne dans un namespace de test. Vous le plafonnez par un quota et des valeurs par défaut, vous prouvez qu'une création hors quota est refusée et qu'un conteneur qui ne déclare rien est complété, vous bornez la charge en marche, puis vous vérifiez qu'une application d'un autre namespace continue de répondre. La validation porte sur l'état du cluster, y compris la tentative de création hors quota, lue sur un essai réel.
Challenge : détecter et contenir une persistance et un déni de service
Section intitulée « Challenge : détecter et contenir une persistance et un déni de service »Le challenge est la preuve sans aide du module, et il est noté sur l'état du cluster que vous laissez, pas sur les commandes tapées. Sans procédure, vous trouvez ce qu'un attaquant a laissé pour garder son accès, vous le consignez avant de le retirer pour de bon sans abîmer l'application légitime, puis vous plafonnez le namespace où tourne une charge abusive.
La validation lit d'abord la persistance : l'objet est nommé dans un fichier de constat, il est supprimé, l'accès ne revient pas même sans le Pod d'origine, et l'application légitime garde tous ses réplicas. Elle lit ensuite le déni de service : le namespace porte un quota, un LimitRange donne des valeurs par défaut, une création hors quota est refusée sur une tentative réelle, et une application d'un autre namespace répond pendant la charge.
Pendant que vous travaillez, dsoxlab check montre ce qui manque, sans dire comment le corriger, et la leçon à reprendre est celle qui enseigne cet état. Le challenge s'appuie sur cette leçon, sur Persistance : ce qu'un attaquant laisse derrière lui, sur Requests et Limits et sur ResourceQuota et LimitRange.
À retenir
Section intitulée « À retenir »- Un déni de service épuise une ressource partagée : processeur et mémoire des nœuds, nombre de Pods, nombre d'objets, requêtes vers l'API server, stockage.
- Un conteneur qui dépasse sa limite de mémoire est arrêté (
OOMKilled, code 137) ; un Pod est évincé (Evicted) quand c'est le nœud qui manque de mémoire. - On plafonne un namespace avec deux objets ensemble : un ResourceQuota pour le total, un LimitRange pour les valeurs par défaut.
- Ces valeurs par défaut sont un filet : chaque manifeste déclare ses propres requests et limits.
- Ni le quota ni le LimitRange ne touchent les Pods déjà en marche : il faut les recréer, par exemple en supprimant les Pods pour que leur ReplicaSet les relance.
- Une création hors quota est refusée avec
exceeded quota; on le prouve par une tentative réelle. - L'API server et etcd sont les composants du plan de contrôle exposés : API Priority and Fairness borne le volume des requêtes, le RBAC limite leur coût, et les quotas d'objets plafonnent ce qu'un namespace peut créer.
- Une charge sans limites pénalise surtout les voisins sans requests ; une charge qui réserve trop bloque le planificateur, et les nouveaux Pods restent
Pending. - L'isolation entre namespaces se prouve en appelant l'application d'un autre namespace pendant la charge, pas en lisant le quota.
Contrôle de connaissances
Section intitulée « Contrôle de connaissances »Vérifiez que l'essentiel de ce guide est acquis. Les questions portent uniquement sur ce qui vient d'être expliqué ici.
Contrôle de connaissances
Validez vos connaissances avec ce quiz interactif
Informations
- Le chronomètre démarre au clic sur Démarrer
- Questions à choix multiples, vrai/faux et réponses courtes
- Vous pouvez naviguer entre les questions
- Les résultats détaillés sont affichés à la fin
Lance le quiz et démarre le chronomètre
Vérification
(0/0)Score par domaine
Un domaine regroupe plusieurs guides et reçoit plusieurs questions : son score est plus fiable qu'un score par thème, qui porte souvent sur une seule question.
Bilan
Points forts
Aucun sujet réussi à 80 % sur au moins deux questions pour l’instant.
Points faibles
Aucun sujet sous le seuil de réussite.
À faire ensuite
Des indices pour retenter votre chance ?
Continuer le cours : CIS Benchmark
Nouveau quiz complet avec des questions aléatoires
Retravailler uniquement les questions ratées
Retour à la liste des certifications