Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 5: Scheduling

Ziel: Du steuerst, wo Pods landen und wie viel sie verbrauchen dürfen – und erkennst sofort, warum ein Pod Pending bleibt. · Dauer: ca. 75 min · Voraussetzung: Tag 4

Briefing

CKA: „Configure Pod admission and scheduling (limits, node affinity, etc.)” (Teil der 15 %).

  • Requests entscheiden über die Platzierung, Limits über die Obergrenze zur Laufzeit.
  • LimitRange setzt Standardwerte, ResourceQuota deckelt einen Namespace.
  • nodeSelector / Affinity ziehen Pods zu Nodes, Taints stoßen sie ab, Tolerations erlauben die Ausnahme.
  • Bleibt ein Pod Pending, steht der Grund in den Events (FailedScheduling).
mkdir -p ~/cka/tag05 && cd ~/cka/tag05
k create ns tag05
k config set-context --current --namespace=tag05

Drill 1: Ein Pod, der nirgends passt

Wie viel ist auf worker1 schon vergeben?

k describe node worker1 | grep -A6 'Allocated resources'

Erwartet (gekürzt):

Allocated resources:
  Resource           Requests    Limits
  --------           --------    ------
  cpu                200m (10%)  0 (0%)
  memory             140Mi (3%)  340Mi (8%)

Jetzt ein Pod, der 8 CPUs anfordert – erzeugt und mit Ressourcen versehen in einer Pipe:

k run big --image=nginx:1.29 $do \
  | k set resources --local -f - --requests=cpu=8 -o yaml | k apply -f -
k get pod big
k get events --field-selector involvedObject.name=big | tail -1

Erwartet (gekürzt):

NAME   READY   STATUS    RESTARTS   AGE
big    0/1     Pending   0          6s
Warning   FailedScheduling   pod/big   0/3 nodes are available: 1 node(s) had
untolerated taint(s), 2 Insufficient cpu. ...

Lies die Meldung genau: cp1 scheidet wegen des Taints aus, die Worker wegen der CPU.

k delete pod big --now

Fortschritt speichern? Kostenlos registrieren

Drill 2: LimitRange und ResourceQuota

k create quota tag05-quota \
  --hard=pods=4,requests.cpu=1,requests.memory=1Gi,limits.memory=2Gi
cat <<'EOF' | k apply -f -
apiVersion: v1
kind: LimitRange
metadata:
  name: defaults
spec:
  limits:
  - type: Container
    default:
      memory: 256Mi
    defaultRequest:
      cpu: 100m
      memory: 128Mi
EOF
k run small --image=nginx:1.29
k get pod small -o jsonpath='{.spec.containers[0].resources}{"\n"}'

Erwartet:

{"limits":{"memory":"256Mi"},"requests":{"cpu":"100m","memory":"128Mi"}}

Der Pod hatte keine Ressourcen – die LimitRange hat sie eingesetzt. Ohne sie würde die Quota den Pod ablehnen, denn mit requests.cpu in der Quota muss jeder Pod Requests haben.

k describe quota tag05-quota | tail -6
k create deployment many --image=nginx:1.29 --replicas=6
k get deployment many

Erwartet:

Resource         Used   Hard
--------         ----   ----
limits.memory    256Mi  2Gi
pods             1      4
requests.cpu     100m   1
requests.memory  128Mi  1Gi
deployment.apps/many created
NAME   READY   UP-TO-DATE   AVAILABLE   AGE
many   3/6     3            3           8s

Nur drei neue Pods – mit small ist die Quota von 4 voll. Den Grund findest du am ReplicaSet, nicht am Deployment:

k describe rs -l app=many | grep -m1 'exceeded quota'

Erwartet (gekürzt):

  Warning  FailedCreate  8s  replicaset-controller  Error creating:
pods "many-6df65cc865-lgb8s" is forbidden: exceeded quota: tag05-quota,
requested: pods=1, used: pods=4, limited: pods=4

Aufräumen:

k delete deployment many
k delete pod small
k delete quota tag05-quota
k delete limitrange defaults

Fortschritt speichern? Kostenlos registrieren

Drill 3: nodeSelector und Node Affinity

k label node worker2 disk=ssd
cat <<'EOF' | k apply -f -
apiVersion: v1
kind: Pod
metadata:
  name: fast
spec:
  nodeSelector:
    disk: ssd
  containers:
  - name: fast
    image: nginx:1.29
---
apiVersion: v1
kind: Pod
metadata:
  name: affine
spec:
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
        - matchExpressions:
          - key: disk
            operator: NotIn
            values: ["ssd"]
          - key: node-role.kubernetes.io/control-plane
            operator: DoesNotExist
  containers:
  - name: affine
    image: nginx:1.29
EOF
k get pods -o custom-columns=NAME:.metadata.name,NODE:.spec.nodeName

Erwartet:

NAME     NODE
affine   worker1
fast     worker2

Ausdrücke innerhalb eines matchExpressions gelten mit UND, mehrere nodeSelectorTerms mit ODER. preferredDuringScheduling… wäre nur ein Wunsch, kein Muss.

k delete pod fast affine --now

Fortschritt speichern? Kostenlos registrieren

Drill 4: Taints und Tolerations

worker1 geht in Wartung – neue Pods sollen ihn meiden:

k taint node worker1 maintenance=true:NoSchedule
k create deployment spread --image=nginx:1.29 --replicas=3
k rollout status deployment spread
k get pods -l app=spread -o custom-columns=NAME:.metadata.name,NODE:.spec.nodeName

Erwartet:

NAME                      NODE
spread-85cb54f4b9-fr7nl   worker2
spread-85cb54f4b9-lkjq6   worker2
spread-85cb54f4b9-w8wgl   worker2

Ein Pod mit passender Toleration darf trotzdem hin:

cat <<'EOF' | k apply -f -
apiVersion: v1
kind: Pod
metadata:
  name: tolerant
spec:
  tolerations:
  - key: maintenance
    operator: Equal
    value: "true"
    effect: NoSchedule
  nodeSelector:
    kubernetes.io/hostname: worker1
  containers:
  - name: tolerant
    image: nginx:1.29
EOF
k get pod tolerant -o wide

Erwartet: tolerant läuft auf worker1. Die Toleration erlaubt den Node, erzwingt ihn aber nicht – dafür sorgt hier der nodeSelector.

Taint wieder entfernen (das - am Ende):

k taint node worker1 maintenance=true:NoSchedule-
k describe node worker1 | grep Taints

Erwartet:

node/worker1 untainted
Taints:             <none>

Fortschritt speichern? Kostenlos registrieren

Drill 5: NoExecute räumt den Node

NoSchedule lässt laufende Pods in Ruhe. NoExecute vertreibt sie:

k taint node worker2 evict=now:NoExecute
k get pods -o custom-columns=NAME:.metadata.name,NODE:.spec.nodeName

Erwartet (nach etwa 10 s):

NAME                      NODE
spread-85cb54f4b9-4vczg   worker1
spread-85cb54f4b9-6fsfr   worker1
spread-85cb54f4b9-nn2dh   worker1
tolerant                  worker1

Alle drei spread-Pods sind auf worker1 umgezogen.

k taint node worker2 evict=now:NoExecute-
k delete deployment spread
k delete pod tolerant --now

Fortschritt speichern? Kostenlos registrieren

Drill 6: Pods verteilen – und eine Falle

cat > spread.yaml <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata:
  name: spread
spec:
  replicas: 4
  selector:
    matchLabels:
      app: spread
  template:
    metadata:
      labels:
        app: spread
    spec:
      topologySpreadConstraints:
      - maxSkew: 1
        topologyKey: kubernetes.io/hostname
        whenUnsatisfiable: DoNotSchedule
        labelSelector:
          matchLabels:
            app: spread
      containers:
      - name: nginx
        image: nginx:1.29
EOF
k apply -f spread.yaml
k get pods -l app=spread -o custom-columns=NAME:.metadata.name,NODE:.spec.nodeName

Erwartet:

NAME                      NODE
spread-867df78bcb-ssvvs   <none>
spread-867df78bcb-b4fl7   <none>
spread-867df78bcb-mhqbk   worker1
spread-867df78bcb-vs768   worker2

Zwei Pods bleiben Pending. Warum?

k get events --field-selector reason=FailedScheduling | tail -1

Erwartet (gekürzt):

Warning   FailedScheduling   pod/spread-867df78bcb-ssvvs   0/3 nodes are available:
1 node(s) had untolerated taint(s), 2 node(s) didn't match pod topology spread
constraints. ...

Der Scheduler zählt cp1 als Verteilungsdomäne mit 0 Pods mit, obwohl dort wegen des Taints nie ein Pod landen kann. Mit 0 auf cp1 erlaubt maxSkew: 1 nur einen Pod pro Worker. Die Lösung: Taints bei der Verteilung berücksichtigen.

sed -i \
  's/^        whenUnsatisfiable: DoNotSchedule/&\n        nodeTaintsPolicy: Honor/' \
  spread.yaml
grep -A1 whenUnsatisfiable spread.yaml
k delete deployment spread
k apply -f spread.yaml
k rollout status deployment spread
k get pods -l app=spread -o custom-columns=NODE:.spec.nodeName --no-headers \
  | sort | uniq -c

Erwartet:

        whenUnsatisfiable: DoNotSchedule
        nodeTaintsPolicy: Honor
deployment.apps "spread" deleted from tag05 namespace
deployment.apps/spread created
deployment "spread" successfully rolled out
      2 worker1
      2 worker2

Warum löschen statt apply auf das laufende Deployment? Topology Spread wirkt nur beim Scheduling. Bei einem Rolling Update zählen die alten Pods noch mit, und die Verteilung bleibt schief.

Fortschritt speichern? Kostenlos registrieren

Drill 7: Static Pod und manuelles Scheduling

Ein Static Pod läuft ohne Scheduler – das kubelet startet ihn aus einer Datei. Auf worker1:

cat <<'EOF' | sudo tee /etc/kubernetes/manifests/static-web.yaml
apiVersion: v1
kind: Pod
metadata:
  name: static-web
  namespace: tag05
spec:
  containers:
  - name: nginx
    image: nginx:1.29
EOF

Zurück auf cp1:

k get pods | grep static
k delete pod static-web-worker1
k get pods | grep static

Erwartet:

static-web-worker1        1/1     Running   0          16s
pod "static-web-worker1" deleted from tag05 namespace
static-web-worker1        0/1     Pending   0          6s

Der Pod ist sofort wieder da – der Name bekommt den Node als Suffix, und gelöscht wird er nur über die Datei. Auf worker1:

sudo rm /etc/kubernetes/manifests/static-web.yaml

Den Scheduler umgehen kannst du auch mit nodeName:

cat <<'EOF' | k apply -f -
apiVersion: v1
kind: Pod
metadata:
  name: manual
spec:
  nodeName: worker2
  containers:
  - name: manual
    image: nginx:1.29
EOF
k get pod manual -o wide

Erwartet: manual läuft auf worker2. nodeName ignoriert Affinity und sogar NoSchedule-Taints – nützlich, wenn der Scheduler selbst kaputt ist (Tag 14).

Fortschritt speichern? Kostenlos registrieren

Übung: Speed-Drills

  1. Lege eine PriorityClass critical mit dem Wert 1000000 an. Zeitziel: 20 s
  2. Markiere worker1 mit zone=a. Zeitziel: 10 s
  3. Mache worker2 für neue Pods unbenutzbar, ohne laufende Pods zu stören, und hebe das wieder auf. Zeitziel: 20 s

Lösung

k create priorityclass critical --value=1000000 --description="wichtige Apps"
k label node worker1 zone=a
k cordon worker2
k uncordon worker2

Erwartet (Ausschnitt):

priorityclass.scheduling.k8s.io/critical created
node/worker1 labeled
node/worker2 cordoned
node/worker2 uncordoned

cordon setzt den Taint node.kubernetes.io/unschedulable:NoSchedule – dasselbe wie ein eigener Taint, nur mit Bordmitteln.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

k get pods -l app=spread -o custom-columns=NODE:.spec.nodeName --no-headers \
  | sort | uniq -c

Erwartet:

      2 worker1
      2 worker2
k describe node worker1 worker2 | grep Taints

Erwartet: zweimal Taints: <none>.

k get pod manual -o jsonpath='{.spec.nodeName}{"\n"}'

Erwartet: worker2

Challenge

Starte einen Pod prio mit der PriorityClass critical, der nur auf Nodes mit dem Label zone=a laufen darf.

Hinweis: priorityClassName steht direkt unter spec.

Lösung

cat <<'EOF' | k apply -f -
apiVersion: v1
kind: Pod
metadata:
  name: prio
spec:
  priorityClassName: critical
  nodeSelector:
    zone: a
  containers:
  - name: prio
    image: nginx:1.29
EOF
k get pod prio -o custom-columns=NODE:.spec.nodeName,PRIO:.spec.priority

Erwartet:

NODE      PRIO
worker1   1000000

Aufräumen:

k config set-context --current --namespace=default
k delete ns tag05
k delete priorityclass critical
k label node worker1 zone-
k label node worker2 disk-

Fortschritt speichern? Kostenlos registrieren

Prüfungstipp

  • Pending? Immer zuerst k describe pod und unten die Events lesen. Die Meldung nennt für jeden Node den Grund.
  • Taint entfernen: dieselbe Zeile mit - am Ende. Label entfernen: key-.
  • Static Pods: Auf dem richtigen Node arbeiten (ssh worker1), Pfad aus /var/lib/kubelet/config.yaml lesen – er kann in der Prüfung abweichen.

Enterprise-Notiz

  • Requests ohne Limits für CPU, aber immer Limits für Memory – sonst OOM-Kills beim Nachbarn.
  • Quotas und LimitRanges pro Team-Namespace gehören zur Mandantenfähigkeit.
  • Topology Spread über topology.kubernetes.io/zone verteilt Pods über Rechenzentren.
  • Für Wartungen k drain statt Taints von Hand (Tag 13).