Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 6: Ressourcen und Namespaces

Ziel: Jeder Container sagt, was er braucht und wie viel Speicher er höchstens nimmt, und der Namespace notes hat 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 allocatable passt.
  • 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 notes

Erwartet:

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}'; echo

Erwartet:

{"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 oom

Erwartet (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.yaml

Erwartet:

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 default

Erwartet (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 cpu

Erwartet (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 limitrange

Erwartet: die LimitRange defaults.

NAME       CREATED AT
defaults   2026-…
kubectl describe quota notes

Erwartet: 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.qosClass

Erwartet: 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 Limits

Erwartet: nur ein Memory-Limit, kein CPU-Limit.

    Limits:
      memory:  64Mi
    Requests:
kubectl get pod oom cpu big

Erwartet: 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 3

Erwartet (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-storage begrenzen, sonst füllt ein Log die Node-Platte.
  • Kubelet reserviert mit kube-reserved und system-reserved Platz 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.