Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 16: Webhooks, APIServices und hängende Namespaces

Ziel: Du findest den Webhook hinter einer abgelehnten Anfrage, erkennst eine nicht verfügbare aggregierte API und bekommst einen Namespace aus Terminating heraus, ohne Objekte in etcd zu verwaisen. · Dauer: ca. 60 min · Voraussetzung: Tag 15

Briefing

  • Admission-Webhooks fragt der API-Server bei jedem passenden Schreibzugriff. failurePolicy: Fail lehnt ab, wenn der Webhook nicht antwortet, Ignore lässt durch – hängt das Backend, erst nach timeoutSeconds.
  • Aggregierte APIs (APIService) leiten ganze API-Gruppen an einen Service weiter. Fehlt das Backend, ist die Discovery des Clusters unvollständig.
  • Ein Namespace verschwindet erst, wenn alles darin gelöscht ist. Woran er hängt, steht in seinen Conditions.
Fehlerbild Symptom Wo die Antwort steht
Webhook ohne Backend failed calling webhook Webhook-Konfiguration, Endpoints
Langsamer Webhook jede Anfrage dauert 10 s timeoutSeconds, API-Server-Log
APIService weg False (MissingEndpoints) kubectl get apiservice
Namespace hängt Terminating ohne Ende .status.conditions

Drill 1: Ein Webhook ohne Backend

Einbauen: Ein Prüf-Webhook für ConfigMaps in tag16, dessen Service keinen Pod hat:

# auf cp1
mkdir -p ~/debug/tag16 && cd ~/debug/tag16
kubectl create namespace tag16
cat > pruefer.yaml <<'EOF'
apiVersion: v1
kind: Service
metadata: {name: pruefer, namespace: tag16}
spec:
  selector: {app: pruefer}
  ports: [{port: 443, targetPort: 8443}]
---
apiVersion: admissionregistration.k8s.io/v1
kind: ValidatingWebhookConfiguration
metadata: {name: tag16-pruefung}
webhooks:
- name: pruefung.tag16.labor.test
  admissionReviewVersions: [v1]
  sideEffects: None
  failurePolicy: Fail
  timeoutSeconds: 5
  clientConfig:
    service: {name: pruefer, namespace: tag16, path: /validate}
  namespaceSelector:
    matchLabels: {kubernetes.io/metadata.name: tag16}
  rules:
  - apiGroups: [""]
    apiVersions: [v1]
    operations: [CREATE, UPDATE]
    resources: [configmaps]
EOF
kubectl apply -f pruefer.yaml

Erwartet:

namespace/tag16 created
service/pruefer created
validatingwebhookconfiguration.admissionregistration.k8s.io/tag16-pruefung created

Der namespaceSelector begrenzt den Schaden auf tag16 – ohne ihn träfe es jeden Namespace.

Symptom:

# auf cp1
kubectl -n tag16 create configmap test --from-literal=a=b

Erwartet (Zeile umbrochen):

error: failed to create configmap: Internal error occurred: failed calling webhook
  "pruefung.tag16.labor.test": failed to call webhook: Post
  "https://pruefer.tag16.svc:443/validate?timeout=5s": no endpoints available for
  service "pruefer"

Untersuchen: Die Meldung nennt den Namen des Webhooks, nicht den der Konfiguration. Beide findest du in der Liste:

# auf cp1
kubectl get validatingwebhookconfigurations
J='{range .items[*]}{.metadata.name}{range .webhooks[*]} {.name} {.failurePolicy}'
kubectl get validatingwebhookconfigurations -o jsonpath="$J{end}{\"\n\"}{end}" \
  | grep tag16
kubectl get validatingwebhookconfiguration tag16-pruefung \
  -o jsonpath='{.webhooks[0].clientConfig.service}{"\n"}'
kubectl -n tag16 get endpointslice

Erwartet (gekürzt):

NAME                                            WEBHOOKS   AGE
kyverno-cel-exception-validating-webhook-cfg    1          163m
...
kyverno-ttl-validating-webhook-cfg              1          164m
tag16-pruefung                                  1          7s
tag16-pruefung pruefung.tag16.labor.test Fail
{"name":"pruefer","namespace":"tag16","path":"/validate","port":443}
NAME            ADDRESSTYPE   PORTS     ENDPOINTS   AGE
pruefer-kpccn   IPv4          <unset>   <unset>     8s

Ursache: Der API-Server muss für jede ConfigMap in tag16 den Webhook fragen. Der Service hat keine Endpoints (Tag 7), der Aufruf scheitert, und wegen failurePolicy: Fail lehnt der API-Server die Anfrage ab. Dasselbe Muster kennst du von Kyverno (Tag 12) – hier ohne Kyverno.

Fix: Richtig ist, das Backend wieder zum Laufen zu bringen. Ist es dauerhaft weg, gehört die Konfiguration gelöscht – das kommt in Drill 2. Hier zuerst das Backend: ein Pod mit dem passenden Label.

# auf cp1
kubectl -n tag16 run pruefer --image=nicolaka/netshoot:v0.15 --labels=app=pruefer \
  -- nc -lk -p 8443
kubectl -n tag16 wait --for=condition=Ready pod/pruefer --timeout=60s
kubectl -n tag16 get endpointslice

Erwartet:

pod/pruefer created
pod/pruefer condition met
NAME            ADDRESSTYPE   PORTS   ENDPOINTS     AGE
pruefer-kpccn   IPv4          8443    10.42.1.133   13s

Nachweis: Der Webhook ist erreichbar – und trotzdem scheitert die Anfrage, nur anders:

# auf cp1
time kubectl -n tag16 create configmap test --from-literal=a=b

Erwartet (Zeile umbrochen):

error: failed to create configmap: Internal error occurred: failed calling webhook
  "pruefung.tag16.labor.test": failed to call webhook: Post
  "https://pruefer.tag16.svc:443/validate?timeout=5s": context deadline exceeded

real    0m5.236s

nc nimmt die Verbindung an, spricht aber kein TLS und antwortet nie. Ein Backend, das „läuft“, ist noch kein funktionierender Webhook. Was passiert, wenn jemand deshalb auf Ignore umstellt, zeigt Drill 2.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Der langsame Webhook

Einbauen: Jemand „entschärft“ den Webhook: Ignore statt Fail, dafür mehr Geduld.

# auf cp1
kubectl patch validatingwebhookconfiguration tag16-pruefung --type=json -p '[
  {"op": "replace", "path": "/webhooks/0/failurePolicy", "value": "Ignore"},
  {"op": "replace", "path": "/webhooks/0/timeoutSeconds", "value": 10}]'

Symptom:

# auf cp1
time kubectl -n tag16 create configmap test2 --from-literal=a=b

Erwartet:

configmap/test2 created

real    0m10.210s

Die ConfigMap entsteht – nach zehn Sekunden. Jede Änderung in tag16 dauert jetzt so lange; mit Pods als Ziel bremst das jedes Deployment und jeden Neustart.

Untersuchen:

# auf cp1
kubectl -n kube-system logs kube-apiserver-cp1 --since=1m \
  | grep -m1 'failing open' | cut -c1-200 | fold -w 86

Erwartet:

W1120 12:01:52.403866       1 dispatcher.go:205] Failed calling webhook, failing open
pruefung.tag16.labor.test: failed calling webhook "pruefung.tag16.labor.test": failed
to call webhook: Post "https

Ursache: Ignore macht den Cluster nicht heil, nur träge: Der API-Server wartet bei jeder Anfrage timeoutSeconds lang und lässt sie dann durch („failing open“). Die Prüfung findet in Wahrheit nie statt.

Fix: Das Backend ist kein Webhook und kommt nicht wieder – die Konfiguration wird gelöscht. Webhook-Konfigurationen selbst laufen nie durch Webhooks; du kannst sie also immer ändern oder löschen:

# auf cp1
kubectl delete validatingwebhookconfiguration tag16-pruefung
kubectl -n tag16 delete pod pruefer

Nachweis:

# auf cp1
time kubectl -n tag16 create configmap test3 --from-literal=a=b

Erwartet:

configmap/test3 created

real    0m0.264s

Fortschritt speichern? Kostenlos registrieren

Drill 3: Die aggregierte API fehlt

Einbauen: Der metrics-server von RKE2 wird „vorübergehend“ abgeschaltet:

# auf cp1
kubectl -n kube-system scale deploy rke2-metrics-server --replicas=0

Symptom (nach etwa 20 Sekunden):

# auf cp1
sleep 20
kubectl top nodes

Erwartet:

error: Metrics API not available

Untersuchen: kubectl top fragt nicht den metrics-server direkt, sondern die API-Gruppe metrics.k8s.io, die der API-Server per APIService weiterleitet:

# auf cp1
kubectl get apiservice | grep -v Local | tr -s ' '
kubectl get apiservice v1beta1.metrics.k8s.io \
  -o jsonpath='{.status.conditions[0].message}{"\n"}' | fold -w 86

Erwartet:

NAME SERVICE AVAILABLE AGE
v1beta1.metrics.k8s.io kube-system/rke2-metrics-server False (MissingEndpoints) 5h30m
endpointslices for service/rke2-metrics-server in "kube-system" have no addresses with
 port name "https"

Alle anderen APIServices tragen Local – sie bedient der API-Server selbst.

Ursache: Der APIService zeigt auf einen Service ohne Endpoints. Das trifft nicht nur kubectl top und den HPA (Tag 17): Die Discovery des ganzen Clusters ist jetzt unvollständig – mit Folgen, die Drill 4 zeigt. Deshalb bleibt der metrics-server bis dahin aus.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Der Namespace bleibt in Terminating

Einbauen: Eine ConfigMap mit einem Finalizer, den kein Controller je entfernt:

# auf cp1
kubectl -n tag16 patch configmap test3 --type=merge \
  -p '{"metadata":{"finalizers":["labor.test/aufraeumen"]}}'
kubectl delete namespace tag16 --wait=false

Erwartet:

configmap/test3 patched
namespace "tag16" deleted

--wait=false, weil kubectl sonst ewig auf das Ende wartet.

Symptom:

# auf cp1
sleep 15
kubectl get ns tag16

Erwartet:

NAME    STATUS        AGE
tag16   Terminating   2m13s

AGE zählt ab dem Anlegen in Drill 1, nicht ab dem Löschen.

Untersuchen: Der Namespace-Controller schreibt in die Conditions, woran er hängt:

# auf cp1
kubectl get ns tag16 -o json | jq -r '.status.conditions[]
  | select(.status=="True") | "\(.type): \(.message)"' | fold -w 86

Erwartet:

NamespaceDeletionDiscoveryFailure: Discovery failed for some groups, 1 failing: unable
 to retrieve the complete list of server APIs: metrics.k8s.io/v1beta1: stale GroupVers
ion discovery: metrics.k8s.io/v1beta1
NamespaceContentRemaining: Some resources are remaining: configmaps. has 1 resource in
stances
NamespaceFinalizersRemaining: Some content in the namespace has finalizers remaining:
labor.test/aufraeumen in 1 resource instances

Ursache: Zwei Dinge halten den Namespace fest. Der Finalizer an der ConfigMap – den entfernt niemand. Und die unvollständige Discovery: Der Controller löscht zwar alles, was er findet, weiß aber nicht, ob in metrics.k8s.io noch Objekte in tag16 liegen – und gibt den Namespace sicherheitshalber nicht frei. Weil der APIService cluster-weit gilt, hängt jeder Namespace, den du in dieser Zeit löschst.

Fix: Zuerst nur der Finalizer – bei einem echten Finalizer prüfst du vorher, welcher Controller ihn setzt und warum er ihn nicht entfernt:

# auf cp1
kubectl -n tag16 patch configmap test3 --type=merge \
  -p '{"metadata":{"finalizers":null}}'
sleep 20
kubectl -n tag16 get configmaps
kubectl get ns tag16
kubectl get ns tag16 -o json | jq -r '.status.conditions[]
  | select(.status=="True") | .type'

Erwartet:

configmap/test3 patched
No resources found in tag16 namespace.
NAME    STATUS        AGE
tag16   Terminating   2m41s
NamespaceDeletionDiscoveryFailure

Die ConfigMap ist weg, der Namespace hängt weiter – an der Discovery. Also die aggregierte API reparieren:

# auf cp1
kubectl -n kube-system scale deploy rke2-metrics-server --replicas=1
kubectl -n kube-system rollout status deploy/rke2-metrics-server
T0=$(date +%s)
until ! kubectl get ns tag16 >/dev/null 2>&1; do sleep 2; done
echo "weg nach $(( $(date +%s) - T0 )) s"

Erwartet:

deployment.apps/rke2-metrics-server scaled
deployment "rke2-metrics-server" successfully rolled out
weg nach 35 s

Nachweis:

# auf cp1
kubectl get apiservice v1beta1.metrics.k8s.io
kubectl get ns tag16

Erwartet:

NAME                     SERVICE                           AVAILABLE   AGE
v1beta1.metrics.k8s.io   kube-system/rke2-metrics-server   True        5h32m
Error from server (NotFound): namespaces "tag16" not found

Der Namespace-Controller versucht es mit Backoff erneut; daher die gute halbe Minute.

Achtung: Im Netz kursiert der Tipp, den Finalizer kubernetes am Namespace selbst über /finalize zu entfernen. Der Namespace ist dann weg, seine Objekte aber nicht unbedingt: Sie bleiben verwaist in etcd und tauchen wieder auf, sobald jemand einen Namespace gleichen Namens anlegt. Behebe immer die Ursache.

Fortschritt speichern? Kostenlos registrieren

Übung: Speed-Drills

  1. Zeig alle Validating- und Mutating-Webhooks mit ihrer failurePolicy. Zeitziel: 60 s
  2. Zeig alle APIServices, die nicht verfügbar sind. Zeitziel: 20 s
  3. Zeig alle Namespaces in Terminating. Zeitziel: 20 s

Lösung

# auf cp1
J='{range .items[*]}{range .webhooks[*]}{.name} {.failurePolicy}{"\n"}{end}{end}'
kubectl get validatingwebhookconfigurations,mutatingwebhookconfigurations \
  -o jsonpath="$J" | sort | uniq -c | sort -rn
kubectl get apiservice | grep False; echo "rc=$?"
kubectl get ns --field-selector=status.phase=Terminating

Erwartet:

      3 kyverno-svc.kyverno.svc Fail
      1 validate-policy.kyverno.svc Fail
      1 protect-generation-labels.kyverno.svc Fail
      1 mutate-policy.kyverno.svc Fail
      1 monitor-webhooks.kyverno.svc Ignore
      1 kyverno-cleanup-controller.kyverno.svc Ignore
      1 kyverno-cleanup-controller.kyverno.svc Fail
rc=1
No resources found

Alle übrigen Webhooks stammen von Kyverno (Tag 12) – fast alle mit Fail. Nur monitor-webhooks (Kyvernos Selbstüberwachung) und einer der beiden Cleanup-Webhooks stehen auf Ignore; fällt Kyverno aus, blockieren die anderen.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

# auf cp1
kubectl get validatingwebhookconfigurations,mutatingwebhookconfigurations \
  | grep -c tag16
kubectl get apiservice | grep -c False
kubectl top nodes | head -2

Erwartet:

0
0
NAME      CPU(cores)   CPU(%)   MEMORY(bytes)   MEMORY(%)
cp1       1137m        28%      1928Mi          16%

Challenge

Ein Kollege hat einen Sidecar-Injektor eingerichtet und den Namespace tag16-app dafür markiert. Seitdem bleibt das Deployment web bei 0/1. Finde den Grund und bring web zum Laufen, ohne den Injektor für andere Namespaces abzuschalten.

# auf cp1
cat > injektor.yaml <<'EOF'
apiVersion: admissionregistration.k8s.io/v1
kind: MutatingWebhookConfiguration
metadata: {name: sidecar-injektor}
webhooks:
- name: inject.sidecar.labor.test
  admissionReviewVersions: [v1]
  sideEffects: None
  failurePolicy: Fail
  clientConfig:
    service: {name: injektor, namespace: tag16-app, path: /mutate}
  namespaceSelector:
    matchLabels: {sidecar: an}
  rules:
  - apiGroups: [""]
    apiVersions: [v1]
    operations: [CREATE]
    resources: [pods]
EOF
kubectl apply -f injektor.yaml
kubectl create namespace tag16-app
kubectl label namespace tag16-app sidecar=an
kubectl -n tag16-app create deployment web --image=traefik/whoami:v1.11

Hinweis: Kein Pod, also eine Ebene höher – und nicht jeder Webhook ist ein validating Webhook.

Lösung

# auf cp1
sleep 5
kubectl -n tag16-app get deploy web
kubectl -n tag16-app events --types=Warning | tail -1 | fold -w 86
kubectl get mutatingwebhookconfigurations
kubectl get ns tag16-app --show-labels

Erwartet (gekürzt):

NAME   READY   UP-TO-DATE   AVAILABLE   AGE
web    0/1     0            0           8s
3s (x11 over 8s)   Warning   FailedCreate   ReplicaSet/web-589cc584cd   Error creating
: Internal error occurred: failed calling webhook "inject.sidecar.labor.test": failed
to call webhook: Post "https://injektor.tag16-app.svc:443/mutate?timeout=10s": service
 "injektor" not found
NAME                                    WEBHOOKS   AGE
kyverno-policy-mutating-webhook-cfg     1          167m
kyverno-resource-mutating-webhook-cfg   0          167m
kyverno-verify-mutating-webhook-cfg     1          167m
sidecar-injektor                        1          9s
NAME        STATUS   AGE   LABELS
tag16-app   Active   10s   kubernetes.io/metadata.name=tag16-app,sidecar=an

Der Injektor greift über den namespaceSelector sidecar: an, sein Service existiert nicht. Für tag16-app reicht es, die Markierung zu entfernen; dann neu ausrollen, weil der ReplicaSet-Controller im Backoff steckt:

# auf cp1
kubectl label namespace tag16-app sidecar-
kubectl -n tag16-app rollout restart deploy/web
kubectl -n tag16-app rollout status deploy/web

Erwartet (gekürzt):

namespace/tag16-app unlabeled
deployment.apps/web restarted
deployment "web" successfully rolled out

Fortschritt speichern? Kostenlos registrieren

Aufräumen

# auf cp1
kubectl delete mutatingwebhookconfiguration sidecar-injektor
kubectl delete namespace tag16-app
kubectl get ns | grep -c tag16

Erwartet:

mutatingwebhookconfiguration.admissionregistration.k8s.io "sidecar-injektor" deleted
namespace "tag16-app" deleted
0

Interview-Notiz

  • failed calling webhook – was zuerst? Den Webhook-Namen aus der Meldung in den Validating- und Mutating-Konfigurationen suchen, dann Service und Endpoints des Ziels prüfen.
  • Fail oder Ignore? Fail für sicherheitsrelevante Prüfungen (lieber blockieren als durchwinken), Ignore nur mit kurzem timeoutSeconds – sonst wird der Cluster träge.
  • Namespace hängt in Terminating? .status.conditions lesen: NamespaceDeletionDiscoveryFailure → APIService reparieren, NamespaceFinalizersRemaining → Controller des Finalizers suchen.

Enterprise-Notiz

  • Jeder Webhook bekommt einen namespaceSelector, der kube-system und die eigenen Plattform-Namespaces ausnimmt; sonst blockiert ein Ausfall die eigene Reparatur.
  • Webhook-Backends mit mehreren Replikas, PodDisruptionBudget und Monitoring (apiserver_admission_webhook_rejection_count, apiserver_admission_webhook_admission_duration_seconds).
  • Beim Entfernen von Operatoren und metrics-server auch deren APIServices und CRDs aufräumen – sonst hängt der nächste Namespace-Löschvorgang.
  • Finalizer nie per Skript massenhaft entfernen; erst den zuständigen Controller finden.