Tag 6: Ressourcen und Namespaces
Ziel: Jeder Container sagt, was er braucht und wie viel Speicher er höchstens nimmt, und der Namespace
noteshat Standardwerte und ein Budget. · Dauer: ca. 75 min · Voraussetzung: Tag 5
Briefing
- Request: Was der Container sicher bekommt. Der
Scheduler plant nur mit Requests – ein Pod passt auf einen Node, wenn
die Summe der Requests dort in
allocatablepasst. - Limit: Die Obergrenze. Über dem Memory-Limit tötet
der Kernel den Prozess (
OOMKilled), über dem CPU-Limit wird er gedrosselt. - Aus Requests und Limits folgt die QoS-Klasse:
Guaranteed,Burstable,BestEffort. Sie bestimmt, wer bei Speichermangel zuerst gehen muss. - LimitRange setzt Standardwerte pro Container, ResourceQuota begrenzt die Summe im Namespace.
Drill 1: Was das Cluster hat
Tagesstart:
source ~/k8s-lab/setup/env.sh
mkdir -p ~/k8s-lab/tag06 && cd ~/k8s-lab/tag06
cp -R "$LAB/code/notes/." . && cp -R "$LAB/code/tag05/notes/." .kubectl get pods -o custom-columns='NAME:.metadata.name,QOS:.status.qosClass'
c='NAME:.metadata.name,CPU:.status.allocatable.cpu,MEMORY:.status.allocatable.memory'
kubectl get nodes -o custom-columns="$c,PODS:.status.allocatable.pods"
kubectl describe node lab-worker | sed -n '/Allocated resources/,/ephemeral/p'Erwartet (gekürzt, Namen und Zahlen weichen bei dir ab):
NAME QOS
api-64c6bb58d6-2srkw BestEffort
…
worker-6fc996c95b-d6f58 BestEffort
NAME CPU MEMORY PODS
lab-control-plane 4 8131784Ki 110
lab-worker 4 8131784Ki 110
lab-worker2 4 8131784Ki 110
Allocated resources:
(Total limits may be over 100 percent, i.e., overcommitted.)
Resource Requests Limits
-------- -------- ------
cpu 100m (2%) 0 (0%)
memory 50Mi (0%) 0 (0%)
ephemeral-storage 0 (0%) 0 (0%)
Alle notes-Pods sind BestEffort: keine Requests, keine
Limits. Der Scheduler rechnet sie mit null, nur kindnet aus
kube-system hat etwas angemeldet. Und jeder kind-Node
meldet die ganze Colima-VM als seine Kapazität – drei
Nodes teilen sich in Wahrheit dieselben 4 CPUs. Im Lab egal, in
Produktion hat jeder Node eigene Hardware.
100m heißt 100 Millicores, ein Zehntel einer CPU.
Speicher zählt in Binärpräfixen: 64Mi sind 64 × 2^20 Byte,
64M wären 64 × 10^6.
Fortschritt speichern? Kostenlos registrieren
Drill 2: LimitRange und ResourceQuota
Der Namespace bekommt Standardwerte und ein Budget. Die Datei
namespace.yaml wächst:
cat > k8s/namespace.yaml <<'EOF'
# k8s/namespace.yaml – Stand Ende Tag 6
apiVersion: v1
kind: Namespace
metadata:
name: notes
---
apiVersion: v1
kind: LimitRange
metadata:
name: defaults
namespace: notes
spec:
limits:
- type: Container
defaultRequest:
cpu: 50m
memory: 64Mi
default:
memory: 128Mi
---
apiVersion: v1
kind: ResourceQuota
metadata:
name: notes
namespace: notes
spec:
hard:
pods: "20"
requests.cpu: "2"
requests.memory: 2Gi
limits.memory: 4Gi
EOF
kubectl apply --dry-run=server -f k8s/namespace.yaml
kubectl apply -f k8s/namespace.yaml
kubectl describe limitrange defaults
kubectl describe quota notesErwartet:
namespace/notes unchanged (server dry run)
limitrange/defaults created (server dry run)
resourcequota/notes created (server dry run)
namespace/notes unchanged
limitrange/defaults created
resourcequota/notes created
Name: defaults
Namespace: notes
Type Resource Min Max Default Request Default Limit Max Limit/Request Ratio
---- -------- --- --- --------------- ------------- -----------------------
Container memory - - 64Mi 128Mi -
Container cpu - - 50m - -
Name: notes
Namespace: notes
Resource Used Hard
-------- ---- ----
limits.memory 0 4Gi
pods 6 20
requests.cpu 0 2
requests.memory 0 2Gi
default ist das Standard-Limit,
defaultRequest der Standard-Request. Ein
CPU-Limit setzt die LimitRange bewusst nicht (Drill 7). Die laufenden
Pods zählen schon mit (pods 6), ihre Requests aber mit
null: LimitRange und Quota prüfen nur beim Anlegen eines Pods,
bestehende bleiben unberührt.
Fortschritt speichern? Kostenlos registrieren
Drill 3: Standardwerte greifen beim Anlegen
worker hat noch keine resources:. Ein neuer Pod
genügt:
kubectl rollout restart deploy/worker >/dev/null
kubectl rollout status deploy/worker >/dev/null
sleep 5 # bis der alte Pod weg ist
w=$(kubectl get pod -l app.kubernetes.io/name=worker -o name)
kubectl get "$w" -o jsonpath='{.spec.containers[0].resources}'; echo
kubectl get "$w" -o jsonpath='{.metadata.annotations.kubernetes\.io/limit-ranger}'
echo; kubectl get "$w" -o jsonpath='{.status.qosClass}'; echoErwartet:
{"limits":{"memory":"128Mi"},"requests":{"cpu":"50m","memory":"64Mi"}}
LimitRanger plugin set: cpu, memory request for container worker; memory limit for
container worker
Burstable
Die LimitRange hat dem Pod beim Anlegen die Standardwerte eingetragen
und das per Annotation vermerkt. Ohne LimitRange würde eine Quota auf
requests.cpu jeden Pod ohne Requests
ablehnen – die beiden gehören zusammen.
Fortschritt speichern? Kostenlos registrieren
Drill 4: Requests und Limits für die App
Jetzt bekommen die drei Deployments eigene Werte. Ausschnitt api (web und worker analog, vollständige Dateien im Begleitcode):
# k8s/api.yaml (Ausschnitt) – Stand Ende Tag 6
resources:
requests:
cpu: 50m
memory: 32Mi
limits:
memory: 64Mi| Dienst | requests.cpu |
requests.memory |
limits.memory |
|---|---|---|---|
| api | 50m | 32Mi | 64Mi |
| web | 50m | 96Mi | 192Mi |
| worker | 20m | 64Mi | 128Mi |
cp "$LAB/code/tag06/notes/k8s/"{api,web,worker}.yaml k8s/
kubectl apply --dry-run=server -f k8s/ | grep configured
kubectl apply -f k8s/ | grep configured
for d in api web worker; do kubectl rollout status deploy/$d >/dev/null; done; sleep 8
kubectl get pods -o custom-columns='NAME:.metadata.name,QOS:.status.qosClass'
kubectl get quota notes
kubectl describe node lab-worker | sed -n '/Allocated resources/,/memory/p'Erwartet (gekürzt):
deployment.apps/api configured (server dry run)
deployment.apps/web configured (server dry run)
deployment.apps/worker configured (server dry run)
deployment.apps/api configured
deployment.apps/web configured
deployment.apps/worker configured
NAME QOS
api-847756b757-cnws2 Burstable
…
worker-5d4f7f4dbd-jx6hz Burstable
NAME REQUEST LIMIT
notes pods: 6/20, requests.cpu: 270m/2, requests.memory: 352Mi/2Gi limits.memory: …
Allocated resources:
(Total limits may be over 100 percent, i.e., overcommitted.)
Resource Requests Limits
-------- -------- ------
cpu 250m (6%) 0 (0%)
memory 210Mi (2%) 320Mi (4%)
requests.cpu 270m = 3 × 50m (api) + 2 × 50m (web) + 20m
(worker). Während eines Rollouts zählen die alten Pods mit, bis sie
wirklich weg sind – dann steht da kurz pods: 7/20. Darum
braucht eine Quota Luft für maxSurge.
| QoS | Bedingung | bei Speichermangel auf dem Node |
|---|---|---|
Guaranteed |
jeder Container: Requests = Limits für CPU und Memory | zuletzt |
Burstable |
mindestens ein Request oder Limit, aber nicht Guaranteed | dazwischen |
BestEffort |
keine Requests, keine Limits | zuerst |
Fortschritt speichern? Kostenlos registrieren
Drill 5: OOMKilled live
Ein Testpod, der Speicher frisst: tail /dev/zero sucht
nach einem Zeilenende, das nie kommt, und puffert dabei alles.
cat > oom.yaml <<'EOF'
# oom.yaml – Testpod: frisst Speicher bis zum Limit
apiVersion: v1
kind: Pod
metadata:
name: oom
spec:
restartPolicy: Never
containers:
- name: oom
image: busybox:1.37
command: [sh, -c, "echo start; tail /dev/zero"]
resources:
requests:
memory: 16Mi
limits:
memory: 32Mi
EOF
kubectl apply -f oom.yaml
kubectl wait --for=jsonpath='{.status.phase}'=Failed pod/oom --timeout 120s
kubectl get pod oom
kubectl describe pod oom | grep -A2 -E '^\s+State:'
kubectl get pod oom -o jsonpath='{.status.qosClass} {.spec.containers[0].resources}'
echo; kubectl delete pod oomErwartet (gekürzt):
pod/oom created
pod/oom condition met
NAME READY STATUS RESTARTS AGE
oom 0/1 OOMKilled 0 8s
State: Terminated
Reason: OOMKilled
Exit Code: 137
Burstable {"limits":{"memory":"32Mi"},"requests":{"cpu":"50m","memory":"16Mi"}}
pod "oom" deleted from notes namespace
Exit 137 = 128 + 9: SIGKILL vom Kernel, keine Chance auf Aufräumen.
Den fehlenden CPU-Request hat die LimitRange ergänzt (50m).
In einem Deployment (restartPolicy: Always) würde das
Kubelet neu starten – und nach ein paar Runden stünde
CrashLoopBackOff da, mit Last State: OOMKilled
in kubectl describe.
Fortschritt speichern? Kostenlos registrieren
Drill 6: Zu groß – Quota und
Pending
Ein Pod, der 5 CPUs anfordert:
cat > big.yaml <<'EOF'
# big.yaml – Testpod mit zu großen Requests
apiVersion: v1
kind: Pod
metadata:
name: big
spec:
containers:
- name: big
image: busybox:1.37
command: [sleep, "3600"]
resources:
requests:
cpu: "5"
memory: 64Mi
limits:
memory: 64Mi
EOF
kubectl apply -f big.yamlErwartet:
Error from server (Forbidden): error when creating "big.yaml": pods "big" is forbidden:
exceeded quota: notes, requested: requests.cpu=5, used: requests.cpu=270m, limited:
requests.cpu=2
Die Quota lehnt schon beim API-Server ab, der Pod entsteht gar nicht.
Im Namespace default gibt es keine Quota – dort kommt der
Pod durch und trifft auf den Scheduler:
kubectl apply -n default -f big.yaml
sleep 5
kubectl get pod big -n default
kubectl describe pod big -n default | sed -n '/^Events/,$p'
kubectl delete pod big -n defaultErwartet (gekürzt):
pod/big created
NAME READY STATUS RESTARTS AGE
big 0/1 Pending 0 6s
Events:
Type Reason Age From Message
---- ------ ---- ---- -------
Warning FailedScheduling 6s default-scheduler 0/3 nodes are available: 1 node(s)
had untolerated taint(s), 2 Insufficient cpu. preemption: 0/3 nodes are available: 3
Preemption is not helpful for scheduling.
pod "big" deleted from default namespace
Kein Node hat 5 CPUs frei, der Control-Plane-Node ist per Taint für
normale Pods gesperrt. Der Pod bleibt Pending, bis Platz
frei wird – notfalls für immer. Insufficient cpu oder
Insufficient memory heißt fast immer: Requests zu groß.
Fortschritt speichern? Kostenlos registrieren
Drill 7: Guaranteed und warum kein CPU-Limit
Ein Pod mit Requests = Limits für CPU und Speicher, der eine CPU voll auslasten will:
cat > cpu.yaml <<'EOF'
# cpu.yaml – Testpod: Endlosschleife mit CPU-Limit
apiVersion: v1
kind: Pod
metadata:
name: cpu
spec:
containers:
- name: cpu
image: busybox:1.37
command: [sh, -c, "while :; do :; done"]
resources:
requests:
cpu: 100m
memory: 16Mi
limits:
cpu: 100m
memory: 16Mi
EOF
kubectl apply -f cpu.yaml && kubectl wait --for=condition=Ready pod/cpu
kubectl get pod cpu -o jsonpath='{.status.qosClass}'; echo
kubectl exec cpu -- cat /sys/fs/cgroup/cpu.max
sleep 10
kubectl exec cpu -- grep -E 'usage_usec|nr_periods|nr_throttled|throttled_usec' \
/sys/fs/cgroup/cpu.stat
kubectl delete pod cpuErwartet (gekürzt, Zahlen weichen ab):
pod/cpu created
pod/cpu condition met
Guaranteed
10000 100000
usage_usec 1530449
nr_periods 149
nr_throttled 149
throttled_usec 5468460
pod "cpu" deleted from notes namespace
cpu.max ist die Umsetzung des Limits im cgroup: 10 ms
Rechenzeit pro 100 ms. Der Pod lief rund 15 s und bekam 1,5 s CPU – in
jeder Periode gedrosselt, obwohl die Nodes fast nichts
zu tun hatten.
Darum hat die notes-App nur ein Memory-Limit. Ein CPU-Request reicht: Er sichert den Anteil bei Konkurrenz, ungenutzte CPU darf der Container mitbenutzen. Ein CPU-Limit bremst dagegen auch, wenn der Node leer ist – sichtbar als lange Antwortzeiten, nie als Fehlermeldung. Speicher ist anders: Ohne Limit kann ein Leck den ganzen Node treffen.
Fortschritt speichern? Kostenlos registrieren
Kontrollpunkt
kubectl get limitrangeErwartet: die LimitRange defaults.
NAME CREATED AT
defaults 2026-…
kubectl describe quota notesErwartet: Quota mit 20 Pods, belegt sind 6 Pods und 270m
CPU-Requests.
Name: notes
Namespace: notes
Resource Used Hard
-------- ---- ----
limits.memory 704Mi 4Gi
pods 6 20
requests.cpu 270m 2
requests.memory 352Mi 2Gi
kubectl get pods -o custom-columns=NAME:.metadata.name,QOS:.status.qosClassErwartet: alle Pods Burstable.
NAME QOS
api-9cfb78c75-4xsz9 Burstable
api-9cfb78c75-9fj7l Burstable
api-9cfb78c75-m9xxr Burstable
web-857bcf49dc-bs5wm Burstable
web-857bcf49dc-wd9gt Burstable
worker-5c46fbcb8-5t879 Burstable
kubectl describe deploy api | grep -A2 LimitsErwartet: nur ein Memory-Limit, kein CPU-Limit.
Limits:
memory: 64Mi
Requests:
kubectl get pod oom cpu bigErwartet: Die Testpods aus den Drills sind aufgeräumt.
Error from server (NotFound): pods "oom" not found
Error from server (NotFound): pods "cpu" not found
Error from server (NotFound): pods "big" not found
Challenge
Skaliere api auf 30 Repliken. Wie viele laufen am Ende, und wo findest du den Grund für den Rest? Skaliere danach zurück auf 3.
Hinweis: Nicht das Deployment legt Pods an, sondern sein ReplicaSet – und die Quota zählt mehr als nur CPU.
Lösung
kubectl scale deploy api --replicas 30
sleep 30
kubectl get deploy api
kubectl get quota notes
kubectl get deploy api \
-o jsonpath='{.status.conditions[?(@.type=="ReplicaFailure")].message}'; echo
kubectl scale deploy api --replicas 3Erwartet (gekürzt):
deployment.apps/api scaled
NAME READY UP-TO-DATE AVAILABLE AGE
api 17/30 17 17 23m
NAME REQUEST LIMIT
notes pods: 20/20, requests.cpu: 970m/2, requests.memory: 800Mi/2Gi limits.memory: …
pods "api-847756b757-q6dj4" is forbidden: exceeded quota: notes, requested: pods=1,
used: pods=20, limited: pods=20
deployment.apps/api scaled
Bei 20 Pods ist Schluss: 17 api, 2 web, 1 worker. Das ReplicaSet
versucht es weiter und meldet FailedCreate in seinen
Events; das Deployment fasst den Grund in der Condition
ReplicaFailure zusammen. Ein
kubectl apply -f k8s/ hätte übrigens auch zurückgestellt –
replicas: 3 steht in der Datei.
Fortschritt speichern? Kostenlos registrieren
Enterprise-Notiz
- Requests nach Messung setzen, nicht nach Gefühl: metrics-server plus
kubectl top, Prometheus oder der Vertical Pod Autoscaler im Empfehlungsmodus. - Quotas pro Team-Namespace sind der übliche Weg, Mandanten zu
trennen; zusätzlich
ephemeral-storagebegrenzen, sonst füllt ein Log die Node-Platte. - Kubelet reserviert mit
kube-reservedundsystem-reservedPlatz fürs System; ohne diese Reserve nimmt ein Pod-Speicherleck den Node mit. - PriorityClasses entscheiden, wer bei Platzmangel verdrängt wird – wichtig für Monitoring- und Ingress-Pods.
- CPU-Limits sind in manchen Umgebungen Pflicht (Abrechnung,
Mandanten). Dann großzügig setzen und die Drosselung
(
container_cpu_cfs_throttled_periods_total) beobachten.