Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 3: Pods bleiben Pending

Ziel: Du liest aus der Meldung des Schedulers, warum ein Pod keinen Knoten findet, und findest den Pod, den es gar nicht gibt. · Dauer: ca. 60 min · Voraussetzung: Tag 1

Briefing

  • Pending heißt: Der Pod existiert, ist aber keinem Knoten zugewiesen. Der Scheduler schreibt den Grund als Event FailedScheduling an den Pod – mit einem Grund für jeden Knoten.
  • Die Meldung zählt Knoten nach Grund: 0/3 nodes are available: 3 Insufficient cpu. Die Summe der Gründe ergibt die Zahl der Knoten.
  • Gibt es gar keinen Pod, hat eine Admission-Prüfung ihn abgelehnt. Dann steht das Event am ReplicaSet.
Fehlerbild Symptom Wo die Antwort steht
Requests zu groß Insufficient cpu Event am Pod, describe node
nodeSelector, Taint untolerated taint(s) Event, Labels, Taints
PVC ohne StorageClass unbound immediate PVCs Event am PVC
schedulerName falsch Pending, keine Events .spec.schedulerName
ResourceQuota Deployment 0/2, keine Pods Event am ReplicaSet

Drill 1: Zu große Requests

Einbauen:

# auf cp1
mkdir -p ~/debug/tag03 && cd ~/debug/tag03
kubectl create namespace tag03
cat > gross.yaml <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata: {name: gross, namespace: tag03}
spec:
  replicas: 1
  selector: {matchLabels: {app: gross}}
  template:
    metadata: {labels: {app: gross}}
    spec:
      containers:
      - name: app
        image: busybox:1.37
        command: [sleep, infinity]
        resources:
          requests: {cpu: "6", memory: 256Mi}
          limits: {memory: 256Mi}
EOF
kubectl apply -f gross.yaml

Symptom:

# auf cp1
kubectl -n tag03 get pods

Erwartet:

NAME                     READY   STATUS    RESTARTS   AGE
gross-67c948f4bc-f8r7z   0/1     Pending   0          5s

Untersuchen:

# auf cp1
kubectl -n tag03 describe pod -l app=gross | sed -n '/^Events/,$p'
kubectl get nodes -o custom-columns=NAME:.metadata.name,\
CPU:.status.allocatable.cpu,MEM:.status.allocatable.memory
kubectl describe node worker1 | sed -n '/Allocated resources/,/memory/p'

Erwartet (Zeile umbrochen):

Events:
  Type     Reason            Age   From               Message
  ----     ------            ----  ----               -------
  Warning  FailedScheduling  5s    default-scheduler  0/3 nodes are available:
  3 Insufficient cpu. preemption: 0/3 nodes are available: 3 Preemption is not
  helpful for scheduling.
NAME      CPU   MEM
cp1       4     12248236Ki
worker1   2     4009840Ki
worker2   2     4009840Ki
Allocated resources:
  (Total limits may be over 100 percent, i.e., overcommitted.)
  Resource           Requests    Limits
  --------           --------    ------
  cpu                600m (30%)  100m (5%)
  memory             256Mi (6%)  128Mi (3%)

Ursache: Kein Knoten hat 6 CPUs zu vergeben, der größte (cp1) hat 4. Der Scheduler rechnet mit Requests, nicht mit tatsächlicher Last: Auf worker1 sind schon 600m durch Systempods reserviert, frei sind 1400m.

Fix:

# auf cp1
kubectl -n tag03 set resources deploy/gross --requests=cpu=500m
kubectl -n tag03 rollout status deploy/gross

Nachweis:

# auf cp1
kubectl -n tag03 get pods -l app=gross -o wide | cut -c1-80

Erwartet:

NAME                     READY   STATUS    RESTARTS   AGE   IP           NODE   NOMINA
gross-6879f5c758-fqfbj   1/1     Running   0          2s    10.42.0.19   cp1    <none>

Warum? preemption: … not helpful heißt: Selbst das Verdrängen niedriger priorisierter Pods würde nicht reichen. Mit PriorityClasses könnte der Scheduler sonst Platz schaffen.

Fortschritt speichern? Kostenlos registrieren

Drill 2: nodeSelector und Taint

worker2 wird zum Batch-Knoten: Label für die Auswahl, Taint gegen alle anderen Pods.

Einbauen:

# auf cp1
kubectl label node worker2 pool=batch
kubectl taint node worker2 pool=batch:NoSchedule
cat > batch.yaml <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata: {name: batch, namespace: tag03}
spec:
  replicas: 1
  selector: {matchLabels: {app: batch}}
  template:
    metadata: {labels: {app: batch}}
    spec:
      nodeSelector: {pool: batch}
      containers:
      - name: app
        image: busybox:1.37
        command: [sleep, infinity]
        resources:
          requests: {cpu: 50m, memory: 32Mi}
EOF
kubectl apply -f batch.yaml

Symptom:

# auf cp1
kubectl -n tag03 get pods -l app=batch
kubectl -n tag03 events --for $(kubectl -n tag03 get pod -l app=batch -o name) \
  | tail -1

Erwartet (Zeile umbrochen):

NAME                    READY   STATUS    RESTARTS   AGE
batch-78ccfd557-7rrn6   0/1     Pending   0          4s
4s          Warning   FailedScheduling   Pod/batch-78ccfd557-7rrn6   0/3 nodes are
  available: 1 node(s) had untolerated taint(s), 2 node(s) didn't match Pod's node
  affinity/selector. preemption: 0/3 nodes are available: 3 Preemption is not
  helpful for scheduling.

1 + 2 = 3: Ein Knoten passt zum Selektor, hat aber den Taint; die anderen beiden passen nicht zum Selektor.

Untersuchen:

# auf cp1
kubectl get nodes -o custom-columns=NAME:.metadata.name,\
POOL:.metadata.labels.pool,TAINTS:.spec.taints
kubectl -n tag03 get pod -l app=batch \
  -o jsonpath='{range .items[0].spec.tolerations[*]}{.key}{"\n"}{end}'

Erwartet:

NAME      POOL     TAINTS
cp1       <none>   <none>
worker1   <none>   <none>
worker2   batch    [map[effect:NoSchedule key:pool value:batch]]
node.kubernetes.io/not-ready
node.kubernetes.io/unreachable

Ursache: Der Pod hat nur die beiden Tolerations, die jeder Pod automatisch bekommt (300 s für not-ready und unreachable, Tag 14). Für pool=batch fehlt eine.

Fix:

# auf cp1
kubectl -n tag03 patch deploy batch --type=merge -p '
spec:
  template:
    spec:
      tolerations: [{key: pool, value: batch, effect: NoSchedule}]'
kubectl -n tag03 rollout status deploy/batch

Nachweis:

# auf cp1
kubectl -n tag03 get pods -l app=batch -o wide | cut -c1-80

Erwartet:

NAME                     READY   STATUS    RESTARTS   AGE   IP          NODE      NOMINA
batch-84487547f6-wff6g   1/1     Running   0          2s    10.42.2.8   worker2   <none>

Warum? Eine Toleration erlaubt nur den Knoten mit Taint, sie zieht den Pod nicht dorthin. Erst der nodeSelector sorgt dafür, dass er auf worker2 landet.

Fortschritt speichern? Kostenlos registrieren

Drill 3: PVC ohne StorageClass

Einbauen:

# auf cp1
cat > datenbank.yaml <<'EOF'
apiVersion: v1
kind: PersistentVolumeClaim
metadata: {name: daten, namespace: tag03}
spec:
  accessModes: [ReadWriteOnce]
  resources: {requests: {storage: 1Gi}}
---
apiVersion: apps/v1
kind: Deployment
metadata: {name: datenbank, namespace: tag03}
spec:
  replicas: 1
  selector: {matchLabels: {app: datenbank}}
  template:
    metadata: {labels: {app: datenbank}}
    spec:
      containers:
      - name: app
        image: busybox:1.37
        command: [sh, -c, 'date >> /daten/start.log; sleep infinity']
        volumeMounts: [{name: daten, mountPath: /daten}]
      volumes:
      - name: daten
        persistentVolumeClaim: {claimName: daten}
EOF
kubectl apply -f datenbank.yaml

Symptom:

# auf cp1
kubectl -n tag03 events --for $(kubectl -n tag03 get pod -l app=datenbank -o name) \
  | tail -1

Erwartet (Zeile umbrochen):

6s          Warning   FailedScheduling   Pod/datenbank-595dffc769-fpjlx   0/3 nodes are
  available: pod has unbound immediate PersistentVolumeClaims. not found

Untersuchen:

# auf cp1
kubectl -n tag03 get pvc daten | cut -c1-72
kubectl -n tag03 describe pvc daten | sed -n '/^Events/,$p'

Erwartet (Zeile umbrochen):

NAME    STATUS    VOLUME   CAPACITY   ACCESS MODES   STORAGECLASS   VOLUMEATTRIBUT
daten   Pending                                                     <unset>
Events:
  Type    Reason         Age              From                         Message
  ----    ------         ----             ----                         -------
  Normal  FailedBinding  1s (x2 over 7s)  persistentvolume-controller  no persistent
  volumes available for this claim and no storage class is set

Ursache: Das PVC nennt keine StorageClass, und im Cluster gibt es keine Default-StorageClass (Tag 0, absichtlich). Ohne Klasse sucht Kubernetes ein passendes, vorhandenes PV – es gibt keins. Die Meldung am Pod ist dabei irreführend knapp; die eigentliche Antwort steht am PVC.

Fix:

# auf cp1
kubectl -n tag03 patch pvc daten -p '{"spec":{"storageClassName":"local-path"}}'

Nachweis:

# auf cp1
kubectl -n tag03 get pvc daten -o custom-columns=NAME:.metadata.name,\
STATUS:.status.phase,SC:.spec.storageClassName
kubectl -n tag03 get pods -l app=datenbank -o wide | cut -c1-80

Erwartet:

NAME    STATUS   SC
daten   Bound    local-path
NAME                         READY   STATUS    RESTARTS   AGE   IP           NODE
datenbank-595dffc769-fpjlx   1/1     Running   0          35s   10.42.1.14   worker1

Warum? Eine fehlende storageClassName darf nachträglich gesetzt werden (nicht aber ein ausdrücklich leerer Wert ""). Eine einmal gesetzte Klasse dagegen nicht:

# auf cp1
kubectl -n tag03 patch pvc daten -p '{"spec":{"storageClassName":"schnell"}}' \
  2>&1 | head -2

Erwartet (Zeile umbrochen):

The PersistentVolumeClaim "daten" is invalid: spec: Forbidden: spec is immutable
  after creation except resources.requests and volumeAttributesClassName for bound
  claims

Dann bleibt nur: PVC löschen und neu anlegen – samt Daten, die schon darin liegen.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Pending ohne ein einziges Event

Einbauen:

# auf cp1
cat > still.yaml <<'EOF'
apiVersion: v1
kind: Pod
metadata: {name: still, namespace: tag03}
spec:
  schedulerName: batch-scheduler
  containers:
  - name: app
    image: busybox:1.37
    command: [sleep, infinity]
EOF
kubectl apply -f still.yaml

Symptom:

# auf cp1
kubectl -n tag03 get pod still -o wide | cut -c1-72
kubectl -n tag03 events --for pod/still

Erwartet:

NAME    READY   STATUS    RESTARTS   AGE   IP       NODE     NOMINATED NODE
still   0/1     Pending   0          15s   <none>   <none>   <none>
No events found in tag03 namespace.

Untersuchen: Kein FailedScheduling heißt: Kein Scheduler hat sich den Pod überhaupt angesehen.

# auf cp1
kubectl -n tag03 get pod still -o jsonpath='{.spec.schedulerName}{"\n"}'

Erwartet:

batch-scheduler

Ursache: Der Pod verlangt einen Scheduler batch-scheduler, den es im Cluster nicht gibt. Der Standard-Scheduler ignoriert ihn, und niemand meldet etwas.

Fix: schedulerName ist nach dem Anlegen unveränderlich:

# auf cp1
kubectl -n tag03 patch pod still -p '{"spec":{"schedulerName":"default-scheduler"}}' \
  2>&1 | head -2
kubectl -n tag03 delete pod still
sed -i 's/batch-scheduler/default-scheduler/' still.yaml
kubectl apply -f still.yaml

Erwartet (Zeile umbrochen):

The Pod "still" is invalid: spec: Forbidden: pod updates may not change fields other
  than `spec.containers[*].image`,`spec.initContainers[*].image`, ...
pod "still" deleted from tag03 namespace
pod/still created

Nachweis:

# auf cp1
kubectl -n tag03 wait pod/still --for=condition=Ready
kubectl -n tag03 events --for pod/still | head -2 | cut -c1-80

Erwartet:

pod/still condition met
LAST SEEN   TYPE     REASON      OBJECT      MESSAGE
2s          Normal   Scheduled   Pod/still   Successfully assigned tag03/still to worker

Dasselbe Bild – Pending ohne Events – zeigt ein Cluster, dessen Scheduler steht (Tag 15).

Der Pod hat seine Aufgabe erfüllt. Lösch ihn, bevor du in Drill 5 die Quota anlegst – sonst zählt sie ihn mit:

# auf cp1
kubectl -n tag03 delete pod still

Erwartet:

pod "still" deleted from tag03 namespace

Fortschritt speichern? Kostenlos registrieren

Drill 5: ResourceQuota – der Pod, den es nicht gibt

Einbauen:

# auf cp1
cat > quota.yaml <<'EOF'
apiVersion: v1
kind: ResourceQuota
metadata: {name: grenze, namespace: tag03}
spec:
  hard: {pods: "10", requests.cpu: "2", requests.memory: 2Gi, limits.memory: 4Gi}
---
apiVersion: apps/v1
kind: Deployment
metadata: {name: web, namespace: tag03}
spec:
  replicas: 2
  selector: {matchLabels: {app: web}}
  template:
    metadata: {labels: {app: web}}
    spec:
      containers:
      - name: web
        image: nginxinc/nginx-unprivileged:1.29
        ports: [{containerPort: 8080}]
EOF
kubectl apply -f quota.yaml

Symptom:

# auf cp1
kubectl -n tag03 get deploy web
kubectl -n tag03 get pods -l app=web

Erwartet:

NAME   READY   UP-TO-DATE   AVAILABLE   AGE
web    0/2     0            0           6s
No resources found in tag03 namespace.

Kein Pod, also auch kein describe pod. Eine Ebene höher fragen:

Untersuchen:

# auf cp1
kubectl -n tag03 describe deploy web | sed -n '/^Conditions/,/^NewReplicaSet/p'
kubectl -n tag03 events --types=Warning | grep ReplicaSet/web | tail -1

Erwartet (Zeilen umbrochen):

Conditions:
  Type             Status  Reason
  ----             ------  ------
  Progressing      True    NewReplicaSetCreated
  Available        False   MinimumReplicasUnavailable
  ReplicaFailure   True    FailedCreate
OldReplicaSets:    <none>
NewReplicaSet:     web-f48975487 (0/2 replicas created)
1s (x2 over 4s)   Warning   FailedCreate   ReplicaSet/web-f48975487   (combined from
  similar events): Error creating: pods "web-f48975487-c9hdr" is forbidden: failed
  quota: grenze: must specify limits.memory for: web; requests.cpu for: web;
  requests.memory for: web

Ursache: Begrenzt eine Quota requests.cpu oder limits.memory, muss jeder neue Pod diese Werte angeben. Der Container web hat gar keine resources, also lehnt die Admission jeden Pod ab. Der ReplicaSet-Controller versucht es weiter, mit Backoff.

Fix:

# auf cp1
kubectl -n tag03 set resources deploy/web --requests=cpu=100m,memory=64Mi \
  --limits=memory=128Mi
kubectl -n tag03 rollout status deploy/web

Nachweis:

# auf cp1
kubectl -n tag03 get deploy web
kubectl -n tag03 describe resourcequota grenze | tail -5

Erwartet:

NAME   READY   UP-TO-DATE   AVAILABLE   AGE
web    2/2     2            2           48s
limits.memory    512Mi  4Gi
pods             5      10
requests.cpu     750m   2
requests.memory  416Mi  2Gi

Die Quota zählt alle Pods im Namespace, auch gross, batch und datenbank.

Fortschritt speichern? Kostenlos registrieren

Übung: Speed-Drills

  1. Zeig alle Pods im Cluster, die auf Pending stehen. Zeitziel: 20 s
  2. Zeig die Taints aller Knoten. Zeitziel: 20 s
  3. Zeig, wie viel von der Quota in tag03 verbraucht ist. Zeitziel: 10 s
  4. Zeig, wie viel CPU auf worker1 schon reserviert ist. Zeitziel: 20 s

Lösung

# auf cp1
kubectl get pods -A --field-selector=status.phase=Pending
kubectl get nodes -o custom-columns=NAME:.metadata.name,TAINTS:.spec.taints
kubectl -n tag03 get resourcequota
kubectl describe node worker1 | grep -A4 'Allocated resources'

Erwartet (gekürzt):

No resources found
NAME      TAINTS
cp1       <none>
worker1   <none>
worker2   [map[effect:NoSchedule key:pool value:batch]]
NAME     REQUEST                                                        LIMIT    ...
grenze   pods: 5/10, requests.cpu: 750m/2, requests.memory: 416Mi/2Gi   limits.m ...
Allocated resources:
  (Total limits may be over 100 percent, i.e., overcommitted.)
  Resource           Requests    Limits
  --------           --------    ------
  cpu                600m (30%)  100m (5%)

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

# auf cp1
kubectl -n tag03 get deploy

Erwartet:

NAME        READY   UP-TO-DATE   AVAILABLE   AGE
batch       1/1     1            1           2m40s
datenbank   1/1     1            1           2m19s
gross       1/1     1            1           3m2s
web         2/2     2            2           92s
# auf cp1
kubectl get pods -A --field-selector=status.phase=Pending

Erwartet:

No resources found

Challenge

Leg in tag03 eine LimitRange an, die pro Container höchstens 500m CPU und 256Mi erlaubt (Default-Limit 200m/128Mi, Default-Request 100m/64Mi), und ein Deployment rechner mit limits: {cpu: "1", memory: 128Mi}. Finde heraus, warum kein Pod entsteht, repariere es und prüf, welche Requests der Pod am Ende hat.

Hinweis: Auch hier hängt die Meldung am ReplicaSet.

Lösung

# auf cp1
cat > rechner.yaml <<'EOF'
apiVersion: v1
kind: LimitRange
metadata: {name: grenzen, namespace: tag03}
spec:
  limits:
  - type: Container
    max: {cpu: 500m, memory: 256Mi}
    default: {cpu: 200m, memory: 128Mi}
    defaultRequest: {cpu: 100m, memory: 64Mi}
---
apiVersion: apps/v1
kind: Deployment
metadata: {name: rechner, namespace: tag03}
spec:
  replicas: 1
  selector: {matchLabels: {app: rechner}}
  template:
    metadata: {labels: {app: rechner}}
    spec:
      containers:
      - name: app
        image: busybox:1.37
        command: [sleep, infinity]
        resources:
          limits: {cpu: "1", memory: 128Mi}
EOF
kubectl apply -f rechner.yaml
kubectl -n tag03 events --types=Warning | grep ReplicaSet/rechner | tail -1
kubectl -n tag03 set resources deploy/rechner --limits=cpu=500m,memory=128Mi
kubectl -n tag03 rollout status deploy/rechner
kubectl -n tag03 get pod -l app=rechner \
  -o jsonpath='{.items[0].spec.containers[0].resources}{"\n"}'

Erwartet (Zeile umbrochen):

2s          Warning   FailedCreate   ReplicaSet/rechner-5dc45f7db6   (combined from
  similar events): Error creating: pods "rechner-5dc45f7db6-j9mmr" is forbidden:
  maximum cpu usage per Container is 500m, but limit is 1
deployment.apps/rechner resource requirements updated
deployment "rechner" successfully rolled out
{"limits":{"cpu":"500m","memory":"128Mi"},"requests":{"cpu":"500m","memory":"128Mi"}}

Warum 500m Request und nicht der Default von 100m? Steht nur ein Limit im Manifest, setzt Kubernetes den Request schon beim Defaulting gleich dem Limit; defaultRequest der LimitRange greift nur, wenn auch kein Limit da ist.

Fortschritt speichern? Kostenlos registrieren

Aufräumen

# auf cp1
kubectl delete namespace tag03
kubectl taint node worker2 pool=batch:NoSchedule-
kubectl label node worker2 pool-
kubectl get nodes -o custom-columns=NAME:.metadata.name,\
POOL:.metadata.labels.pool,TAINTS:.spec.taints
kubectl get pv

Erwartet:

namespace "tag03" deleted
node/worker2 untainted
node/worker2 unlabeled
NAME      POOL     TAINTS
cp1       <none>   <none>
worker1   <none>   <none>
worker2   <none>   <none>
No resources found

Interview-Notiz

  • Ein Pod hängt in Pending – wo schaust du? Events am Pod (FailedScheduling), die Zahlen pro Grund summieren sich zur Knotenzahl. Bei Volumes weiter zum PVC.
  • Deployment zeigt 0/2, aber es gibt keine Pods? Admission hat sie abgelehnt (Quota, LimitRange, Pod Security, Webhook) – Event am ReplicaSet bzw. Condition ReplicaFailure am Deployment.
  • Taint oder nodeSelector? Taint hält fremde Pods fern, nodeSelector/Affinity zieht eigene hin; für dedizierte Knoten brauchst du beides.

Enterprise-Notiz

  • Quotas pro Team-Namespace sind üblich; eine LimitRange mit Defaults daneben verhindert, dass Pods ohne resources abgelehnt werden.
  • Cluster-Autoscaler legt nur Knoten an, wenn ein neuer Knoten aus einer Node-Gruppe den Pod aufnehmen könnte. Fehlen Toleration, passendes Label oder StorageClass, wartet der Pod für immer.
  • Genau eine Default-StorageClass pro Cluster festlegen und dokumentieren; zwei Defaults sind ebenfalls ein Fehlerbild.
  • PriorityClasses entscheiden, wer bei Knappheit verdrängt wird – Plattform-Pods höher als Anwendungen.