Aller au contenu
English
Compte : non connecté, synchronisation possible Mon apprentissage
Selectionner le thème
English

Déni de service : épuiser un cluster

Par mis à jour le

Améliorer cette page

Logo Kubernetes

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.

  • 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.

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éeCe qu'on observeContrôle
Processeur d'un nœudLes Pods qui ne déclarent pas de requests ralentissentrequests.cpu et limits.cpu sur chaque conteneur, quota de processeur du namespace
Mémoire d'un nœudConteneur arrêté pour mémoire, Pods évincés, nœud sous pressionlimits.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 PIDPressureLimite de processus par Pod du kubelet (podPidsLimit)
Disque local d'un nœudJournaux ou fichiers temporaires remplissent le disque, condition DiskPressure, Pods évincésQuota limits.ephemeral-storage du namespace
Capacité réservableUne charge qui déclare des requests très élevées épuise ce que le planificateur peut réserver, et les nouveaux Pods restent PendingQuotas requests.cpu et requests.memory du namespace
Nombre de PodsLe planificateur ne trouve plus de place ; un nœud accepte 110 Pods par défautQuota pods du namespace
Nombre d'objetsetcd grossit, le plan de contrôle ralentitQuotas d'objets count/...
Requêtes vers l'API serverLes commandes kubectl et les contrôleurs répondent lentementAPI Priority and Fairness borne le volume de requêtes, RBAC limite leur coût
StockageVolumes saturés, etcd pleinQuota 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.

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/v1
kind: Deployment
metadata:
name: charge-gourmande
namespace: essai-charge
spec:
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.

Fenêtre de terminal
kubectl top nodes
kubectl top pods -n essai-charge --sort-by=cpu
kubectl 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 :

Fenêtre de terminal
kubectl get pods -A --field-selector=status.phase=Failed
kubectl get events -A --sort-by=.metadata.creationTimestamp

Un 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.

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: v1
kind: ResourceQuota
metadata:
name: plafond
namespace: essai-charge
spec:
hard:
pods: "5"
requests.cpu: 500m
requests.memory: 512Mi
limits.cpu: "1"
limits.memory: 1Gi
---
apiVersion: v1
kind: LimitRange
metadata:
name: valeurs-par-defaut
namespace: essai-charge
spec:
limits:
- type: Container
defaultRequest:
cpu: 100m
memory: 64Mi
default:
cpu: 200m
memory: 128Mi

Avec 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 :

Fenêtre de terminal
kubectl describe resourcequota plafond -n essai-charge

La 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.

Fenêtre de terminal
kubectl delete pods -l app=charge-gourmande -n essai-charge
kubectl get pods -n essai-charge \
-o custom-columns=NOM:.metadata.name,CPU_LIMIT:.spec.containers[0].resources.limits.cpu

La 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: 128Mi

Un 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 :

Fenêtre de terminal
kubectl apply -n essai-charge -f - <<'EOF'
apiVersion: v1
kind: Pod
metadata:
name: trop-gros
spec:
containers:
- name: attente
image: busybox:1.38.0@sha256:a46257e06c82ad85242d0d38077d0a52d9896389ca60a1a59d3463db586e5fa4
command: ["sleep", "3600"]
resources:
requests:
cpu: "2"
memory: 64Mi
limits:
cpu: "2"
memory: 128Mi
EOF

Le 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.

Fenêtre de terminal
kubectl get deployment annuaire -n espace-annuaire
kubectl run sonde -n espace-annuaire --rm -i --restart=Never \
--image=busybox:1.38.0@sha256:a46257e06c82ad85242d0d38077d0a52d9896389ca60a1a59d3463db586e5fa4 \
-- wget -qO- -T 3 http://annuaire

La 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.

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.

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.

  • 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.

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

8 questions
8 min.
70% requis

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