Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 13: Kubernetes beobachten

Ziel: Du liest Speicher, CPU und Neustarts der Pods aus Prometheus, erkennst einen OOMKill in Metriken und Events und weißt, welche fertigen Alarme das Chart dafür mitbringt. · Dauer: ca. 60 min · Voraussetzung: Tag 12

Briefing

  • Bisher hast du notes-api von innen beobachtet: mit Metriken, Logs und Traces, die die Anwendung selbst liefert. Kubernetes sieht sie von außen – und das reicht oft, um ein Problem zu finden, bevor du den Code kennst.
  • Drei Quellen liefern das Bild, alle seit Tag 2 im Cluster:
    • cAdvisor im Kubelet misst, was Container verbrauchen: CPU, Speicher, Netz.
    • kube-state-metrics übersetzt, was Kubernetes weiß: Limits, Neustarts, gewünschte und bereite Replikas, Gründe für das Ende eines Containers.
    • node-exporter misst die Maschine darunter.
  • Events sind die vierte Quelle: kurze Meldungen wie „Back-off restarting failed container“. Kubernetes vergisst sie nach einer Stunde – es sei denn, jemand sammelt sie ein.
 Kubelet/cAdvisor ─► container_*        (Verbrauch)
 kube-state-metrics ─► kube_*           (Zustand)      ──► Prometheus
 node-exporter ─► node_*                (Maschine)
 Events ─► Alloy ─► Loki                (Meldungen)

Drill 1: Speicher und CPU

promtool query instant http://localhost:30090 \
  'sum by (pod) (container_memory_working_set_bytes{namespace="app", container!=""})'

Erwartet (die Zahlen weichen ab):

{pod="last-6fdd4b976d-47f97"} => 3448832 @[...]
{pod="postgres-0"} => 64946176 @[...]
{pod="notes-api-76d9df4449-zgs5d"} => 8589312 @[...]
{pod="notes-api-76d9df4449-8rszn"} => 8118272 @[...]
  • working_set ist der Speicher, den der Kernel nicht einfach freigeben kann. An dieser Zahl misst Kubernetes das Limit – überschreitet sie es, folgt der OOMKill.
  • container!="" wirft die Zeitreihen für den ganzen Pod weg, die cAdvisor zusätzlich liefert. Ohne den Filter zählt alles doppelt.
promtool query instant http://localhost:30090 \
  'sum by (pod) (rate(container_cpu_usage_seconds_total{namespace="app",
     container!=""}[5m]))'

Erwartet (gekürzt):

{pod="last-6fdd4b976d-47f97"} => 0.014055368674208252 @[...]
{pod="postgres-0"} => 0.046181930503317176 @[...]
{pod="notes-api-76d9df4449-zgs5d"} => 0.015034315387111894 @[...]
{pod="notes-api-76d9df4449-8rszn"} => 0.014257365085933305 @[...]
  • CPU ist ein Counter in Sekunden. rate() macht daraus „Kerne“: 0,046 heißt 46 Millikerne, also 4,6 Prozent eines Kerns.
  • Pods, die es nicht mehr gibt, stehen noch fünf Minuten im Fenster – wie an Tag 3.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Verbrauch gegen Limit

Wie nah ist jeder Container an seinem Speicherlimit?

promtool query instant http://localhost:30090 '
  max by (pod, container) (container_memory_working_set_bytes{namespace="app",
      container!=""})
    / max by (pod, container) (kube_pod_container_resource_limits{namespace="app",
        resource="memory"})'

Erwartet (gekürzt):

{container="lesen", pod="last-6fdd4b976d-47f97"} => 0.0633544921875 @[...]
{container="postgres", pod="postgres-0"} => 0.249237060546875 @[...]
{container="schreiben", pod="last-6fdd4b976d-47f97"} => 0.0465087890625 @[...]
{container="notes-api", pod="notes-api-76d9df4449-zgs5d"} => 0.063995361328125 @[...]
{container="notes-api", pod="notes-api-76d9df4449-8rszn"} => 0.06048583984375 @[...]
  • Die Division verbindet zwei Metriken aus verschiedenen Quellen. PromQL paart Zeitreihen mit gleichen Labels – darum fasst max by (pod, container) beide Seiten auf dieselben zwei Labels zusammen.
  • Postgres nutzt ein Viertel seiner 256 Mi. notes-api ist mit 128 Mi großzügig ausgestattet.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Ein Container, der zu viel will

Ein Pod, der Speicher frisst, bis das Limit zuschlägt:

cd ~/obs-lab
cat > speicherfresser.yaml <<'EOF'
apiVersion: v1
kind: Pod
metadata:
  name: speicherfresser
  namespace: app
  labels:
    app.kubernetes.io/name: speicherfresser
spec:
  containers:
    - name: fresser
      image: busybox:1.37
      command: [sh, -c, "sleep 20; tail /dev/zero"]
      resources:
        requests: {memory: 16Mi}
        limits: {memory: 32Mi}
EOF
kubectl apply -f speicherfresser.yaml

Erwartet:

pod/speicherfresser created

tail /dev/zero sucht in einem endlosen Strom aus Nullbytes nach dem Zeilenende und hält alles im Speicher. Nach 20 Sekunden Schlaf dauert es einen Augenblick bis zu den 32 Mi. Nach einer Minute:

kubectl -n app get pod speicherfresser

Erwartet (je nach Moment Running, OOMKilled oder CrashLoopBackOff):

NAME              READY   STATUS    RESTARTS      AGE
speicherfresser   1/1     Running   2 (16s ago)   61s

Kubernetes startet den Container immer wieder und wartet dazwischen immer länger. Was sagt Prometheus?

promtool query instant http://localhost:30090 \
  'kube_pod_container_status_last_terminated_reason{namespace="app"} == 1'

Erwartet (gekürzt):

kube_pod_container_status_last_terminated_reason{container="fresser", ...,
pod="speicherfresser", reason="OOMKilled", ...} => 1 @[...]
promtool query instant http://localhost:30090 \
  'increase(kube_pod_container_status_restarts_total{pod="speicherfresser"}[5m])'

Erwartet (ungefähr):

{container="fresser", ...} => 1.6 @[...]

Keine ganze Zahl: increase rechnet bis an die Ränder des Fensters hoch, wie an Tag 3.

  • kube-state-metrics kennt den Grund des letzten Endes: OOMKilled, Error, Completed. Als Label mit Wert 1 – ein Info-Muster wie notes_build_info.
  • Neustarts sind ein Counter. increase über fünf Minuten ist die Grundlage des fertigen Alarms KubePodCrashLooping.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Die fertigen Alarme

promtool query instant http://localhost:30090 'ALERTS{namespace="app"}'

Erwartet (nach zwei bis drei Minuten, gekürzt):

ALERTS{alertname="NotesSloSlowBurn", alertstate="firing", namespace="app",
severity="warning"} => 1 @[...]
ALERTS{alertname="KubePodNotReady", alertstate="pending", ..., pod="speicherfresser",
severity="warning"} => 1 @[...]
  • NotesSloSlowBurn ist dein Alarm aus Tag 12: Der Totalausfall dort steckt noch im Fenster von sechs Stunden – und, wenn du direkt weitergemacht hast, auch noch im Fenster von 30 Minuten. Fehlt die Zeile, ist Tag 12 schon länger her.
  • KubePodNotReady meldet den Speicherfresser. Je nach Moment steht dort auch KubePodCrashLooping – beide sind pending.

Die Kubernetes-Alarme hast du nicht geschrieben. Sie stammen aus den Regeln des Charts:

kubectl -n monitoring get prometheusrule -o name | wc -l
kubectl -n monitoring get prometheusrule kps-kubernetes-apps \
  -o jsonpath='{.spec.groups[0].rules[0].expr}{"\n"}'

Erwartet:

30
max_over_time(kube_pod_container_status_waiting_reason{reason="CrashLoopBackOff", job...
  • 30 PrometheusRule-Objekte mit Regeln für Knoten, Pods, Volumes, den API-Server und den Stack selbst. Sie stammen aus dem Projekt kubernetes-mixin.
  • Die zweite Zeile ist die Regel von KubePodCrashLooping. Sie feuert nach 15 Minuten (for: 15m), bis dahin bleibt sie pending. Du musst nicht warten – der Mechanismus ist derselbe wie an Tag 4.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Events einsammeln

Was Kubernetes über den Speicherfresser zu sagen hat:

kubectl -n app get events --field-selector involvedObject.name=speicherfresser

Erwartet (gekürzt):

LAST SEEN   TYPE      REASON      OBJECT                MESSAGE
2m33s       Normal    Scheduled   pod/speicherfresser   Successfully assigned app/spe...
2m32s       Normal    Pulling     pod/speicherfresser   Pulling image "busybox:1.37"
...
32s         Warning   BackOff     pod/speicherfresser   Back-off restarting failed co...

Diese Meldungen sind nach einer Stunde weg. Alloy kann sie nach Loki schicken – eine Komponente mehr in der Kette. Hier die ganze alloy.yaml:

cat > alloy.yaml <<'EOF'
controller:
  type: deployment

alloy:
  resources:
    requests: {cpu: 20m, memory: 64Mi}
    limits: {memory: 256Mi}
  configMap:
    content: |
      discovery.kubernetes "pods" {
        role = "pod"
      }

      discovery.relabel "pods" {
        targets = discovery.kubernetes.pods.targets
        rule {
          source_labels = ["__meta_kubernetes_namespace"]
          target_label  = "namespace"
        }
        rule {
          source_labels = ["__meta_kubernetes_pod_name"]
          target_label  = "pod"
        }
        rule {
          source_labels = ["__meta_kubernetes_pod_container_name"]
          target_label  = "container"
        }
        rule {
          source_labels = ["__meta_kubernetes_pod_label_app_kubernetes_io_name"]
          target_label  = "app"
        }
      }

      loki.source.kubernetes "pods" {
        targets    = discovery.relabel.pods.output
        forward_to = [loki.write.default.receiver]
      }

      loki.source.kubernetes_events "events" {
        job_name   = "kubernetes-events"
        log_format = "logfmt"
        forward_to = [loki.write.default.receiver]
      }

      loki.write "default" {
        endpoint {
          url = "http://loki:3100/loki/api/v1/push"
        }
      }
EOF
helm upgrade alloy grafana/alloy --version 1.15.0 -n monitoring -f alloy.yaml --wait

Erwartet (gekürzt):

Release "alloy" has been upgraded. Happy Helming!
...
STATUS: deployed

loki.source.kubernetes_events beobachtet die Events aller Namespaces und schreibt jedes als Logzeile – mit job="kubernetes-events" und dem Namespace als Label.

Nach einem weiteren Neustart des Speicherfressers:

logcli query --quiet -o raw --limit 3 --since 5m \
  '{job="kubernetes-events", namespace="app"} |= "speicherfresser"'

Erwartet (gekürzt):

name=speicherfresser kind=Pod ... reason=Started type=Normal count=6 msg="Contai...
name=speicherfresser kind=Pod ... reason=Created type=Normal count=6 msg="Contai...
name=speicherfresser kind=Pod ... reason=Pulled type=Normal count=5 msg="Contain...

count=6: Kubernetes fasst gleiche Events zusammen und zählt mit.

Jetzt bleiben die Events drei Tage – so lange wie alle Logs.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

Räume den Speicherfresser weg:

kubectl -n app delete pod speicherfresser

Erwartet:

pod "speicherfresser" deleted from app namespace
logcli query --quiet -o raw --limit 1 --since 15m \
  '{job="kubernetes-events", namespace="app"} |= "Killing"'

Erwartet (gekürzt):

name=speicherfresser kind=Pod ... reason=Killing type=Normal count=1 msg="Stopping co...

Auch das Löschen ist ein Event – und landet jetzt in Loki.

Challenge

Welche drei Container im ganzen Cluster brauchen gerade den meisten Speicher?

Hinweis: topk(3, …) behält die drei größten Zeitreihen. Ohne Filter auf den Namespace.

Lösung

promtool query instant http://localhost:30090 \
  'topk(3, max by (namespace, container) (
     container_memory_working_set_bytes{container!=""}))'

Erwartet (ungefähr):

{container="prometheus", namespace="monitoring"} => 530051072 @[...]
{container="grafana", namespace="monitoring"} => 295194624 @[...]
{container="tempo", namespace="monitoring"} => 165629952 @[...]

Die Werkzeuge zum Beobachten brauchen mehr Speicher als das, was sie beobachten. Darum kommt an Tag 14 der Betrieb des Stacks selbst dran.

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • Requests ehrlich setzen: Die Abfrage aus Drill 2 mit requests statt limits zeigt, wer zu viel reserviert. Überhöhte Requests verschwenden Knoten, zu niedrige führen zu Verdrängung. Werkzeuge wie der Vertical Pod Autoscaler schlagen Werte vor.
  • CPU-Limits und Drosselung: container_cpu_cfs_throttled_periods_total zeigt, wie oft ein Container an sein CPU-Limit stieß. Viele Teams setzen darum nur CPU-Requests und keine Limits.
  • Events mit Bedacht: In großen Clustern sind Events laut. Filtere in Alloy nach type=Warning oder nach Namespaces, bevor sie in Loki landen.