Kubernetes Job Status und Logs überwachen – Anleitung

Einführung

Kubernetes ist eine leistungsstarke Container-Orchestrierungsplattform, die bei der Verwaltung von containerisierten Anwendungen über mehrere Hosts hinweg hilft. Eine wichtige Funktion von Kubernetes ist sein Job-Management-System, mit dem Sie Batch-orientierte Workloads bis zur Fertigstellung ausführen können. In diesem Tutorial erfahren Sie, wie Sie den Status von Kubernetes-Jobs überwachen und deren Logs analysieren können – wesentliche Fähigkeiten, um sicherzustellen, dass Ihre containerisierten Anwendungen reibungslos laufen.

Am Ende dieses Tutorials werden Sie in der Lage sein, Kubernetes-Jobs zu erstellen, deren Status zu überprüfen und deren Logs zu untersuchen, um Probleme effektiv zu beheben.

Einrichten Ihrer Kubernetes-Umgebung

Bevor wir Kubernetes-Jobs überwachen können, müssen wir eine funktionierende Kubernetes-Umgebung einrichten. Wir verwenden Minikube, ein Tool, das einen Single-Node-Kubernetes-Cluster auf Ihrem lokalen Rechner erstellt.

Installieren von Minikube

Minikube ist bereits auf Ihrer VM installiert. Überprüfen wir die Installation, indem wir die Version überprüfen:

minikube version

Sie sollten eine Ausgabe ähnlich dieser sehen:

minikube version: v1.29.0
commit: ddac20b4b34a9c8c857fc602203b6ba2679794d3

Starten von Minikube

Starten wir nun Minikube, um einen lokalen Kubernetes-Cluster zu erstellen:

minikube start --driver=docker

Dieser Befehl benötigt einige Minuten, um abgeschlossen zu werden. Sie sehen eine Reihe von Meldungen, während Minikube die notwendigen Komponenten herunterlädt und den Cluster startet.

Sobald der Vorgang abgeschlossen ist, sollten Sie eine Meldung wie diese sehen:

🏄  Done! kubectl is now configured to use "minikube" cluster and "default" namespace by default

Überprüfen der Kubernetes-Installation

Überprüfen wir, ob unser Kubernetes-Cluster korrekt läuft, indem wir den Knotenstatus überprüfen:

kubectl get nodes

Sie sollten eine Ausgabe ähnlich dieser sehen:

NAME       STATUS   ROLES           AGE     VERSION
minikube   Ready    control-plane   1m      v1.26.3

Überprüfen Sie außerdem, ob die Kernkomponenten von Kubernetes laufen:

kubectl get pods -n kube-system

Sie sollten mehrere laufende Pods sehen, einschließlich Komponenten wie kube-apiserver, kube-controller-manager und andere.

Da wir nun einen laufenden Kubernetes-Cluster haben, sind wir bereit, Jobs zu erstellen und zu überwachen.

Erstellen Ihres ersten Kubernetes-Jobs

In diesem Schritt erstellen wir einen einfachen Kubernetes-Job, der einen Container ausführt, eine Aufgabe ausführt und dann abgeschlossen wird. Dies gibt uns etwas, das wir in den folgenden Schritten überwachen können.

Kubernetes-Jobs verstehen

Ein Kubernetes-Job ist ein Controller, der einen oder mehrere Pods erstellt und sicherstellt, dass diese erfolgreich beendet werden. Jobs sind nützlich für Batch-Prozesse, einmalige Aufgaben oder jede Aufgabe, die bis zum Abschluss und nicht auf unbestimmte Zeit ausgeführt werden soll.

Erstellen einer Job-Konfigurationsdatei

Erstellen wir eine einfache Job-Konfigurationsdatei. Öffnen Sie ein Terminal und erstellen Sie eine neue Datei namens hello-job.yaml in Ihrem Projektverzeichnis:

cd ~/project
nano hello-job.yaml

Kopieren Sie den folgenden YAML-Inhalt und fügen Sie ihn in die Datei ein:

apiVersion: batch/v1
kind: Job
metadata:
  name: hello-job
spec:
  template:
    spec:
      containers:
        - name: hello
          image: busybox:1.28
          command: ["sh", "-c", 'echo "Hello, Kubernetes!" && sleep 5']
      restartPolicy: Never
  backoffLimit: 4

Diese Konfiguration definiert einen Job namens hello-job, der:

• Das Container-Image busybox:1.28 verwendet
• Einen Befehl ausführt, der "Hello, Kubernetes!" ausgibt und dann 5 Sekunden lang schläft
• Eine Restart-Policy von Never hat, was bedeutet, dass er nach Abschluss nicht neu gestartet wird
• Ein backoffLimit von 4 hat, was bedeutet, dass er bis zu 4 Mal wiederholt wird, wenn er fehlschlägt

Speichern Sie die Datei, indem Sie Ctrl+O, dann Enter drücken und nano mit Ctrl+X beenden.

Erstellen des Jobs

Erstellen wir nun den Job in unserem Kubernetes-Cluster:

kubectl apply -f hello-job.yaml

Sie sollten die Ausgabe sehen:

job.batch/hello-job created

Herzlichen Glückwunsch! Sie haben gerade Ihren ersten Kubernetes-Job erstellt. Im nächsten Schritt erfahren wir, wie man seinen Status überwacht.

Überwachen des Kubernetes-Job-Status

Nachdem wir nun einen Job in unserem Kubernetes-Cluster ausführen, wollen wir lernen, wie man seinen Status überwacht. Die Überwachung des Job-Status ist entscheidend, um zu verstehen, ob Ihre Jobs erfolgreich abgeschlossen werden oder Fehler auftreten.

Überprüfen des Job-Status mit kubectl

Das primäre Werkzeug zur Überwachung von Kubernetes-Ressourcen ist kubectl. Verwenden wir es, um den Status unseres Jobs zu überprüfen:

kubectl get jobs

Sie sollten eine Ausgabe ähnlich dieser sehen:

NAME        COMPLETIONS   DURATION   AGE
hello-job   1/1           10s        30s

Diese Ausgabe zeigt:

• NAME: Der Name des Jobs
• COMPLETIONS: Die Anzahl der abgeschlossenen Pods / gewünschten Abschlüsse
• DURATION: Wie lange der Job zur Ausführung benötigte
• AGE: Wie lange der Job seit seiner Erstellung existiert

Wenn Ihr Job unter COMPLETIONS 0/1 anzeigt, läuft er möglicherweise noch oder ist fehlgeschlagen. Warten Sie ein paar Sekunden und führen Sie den Befehl erneut aus.

Detaillierte Job-Informationen abrufen

Um detailliertere Informationen über einen Job zu erhalten, verwenden Sie den Befehl describe:

kubectl describe job hello-job

Dieser Befehl liefert umfassende Informationen über den Job, einschließlich:

• Labels und Annotationen
• Selektor-Details
• Parallelitäts- und Abschlussanforderungen
• Pod-Status
• Ereignisse im Zusammenhang mit dem Job

Suchen Sie nach dem Abschnitt Events am Ende, der wichtige Ereignisse wie die Erstellung und den Abschluss von Pods anzeigt.

Den Job-Status verstehen

Ein Job kann verschiedene Status haben:

• Active: Der Job läuft noch
• Completed: Der Job wurde erfolgreich abgeschlossen
• Failed: Der Job ist fehlgeschlagen, nachdem er sein Backoff-Limit erreicht hat

Überprüfen wir, ob der Pod unseres Jobs abgeschlossen wurde:

kubectl get pods

Sie sollten so etwas sehen:

NAME              READY   STATUS      RESTARTS   AGE
hello-job-abcd1   0/1     Completed   0          1m

Die Spalte STATUS zeigt Completed an, was darauf hindeutet, dass unser Job erfolgreich ausgeführt wurde.

Erstellen eines Jobs, der länger dauert

Erstellen wir einen weiteren Job, der länger dauert, damit wir ihn im Active-Zustand beobachten können:

cd ~/project
nano long-job.yaml

Kopieren Sie den folgenden YAML-Inhalt und fügen Sie ihn ein:

apiVersion: batch/v1
kind: Job
metadata:
  name: long-job
spec:
  template:
    spec:
      containers:
        - name: long
          image: busybox:1.28
          command:
            [
              "sh",
              "-c",
              'echo "Starting long job..." && sleep 30 && echo "Long job completed!"'
            ]
      restartPolicy: Never
  backoffLimit: 4

Speichern Sie die Datei und beenden Sie nano. Erstellen Sie dann den Job:

kubectl apply -f long-job.yaml

Überprüfen wir nun sofort seinen Status:

kubectl get jobs

Sie sollten sehen, dass long-job 0/1 Abschlüsse anzeigt, da er noch läuft. Wenn Sie alle paar Sekunden nachsehen, werden Sie schließlich sehen, dass er sich nach etwa 30 Sekunden auf 1/1 ändert.

Dies zeigt, wie Sie den Fortschritt Ihrer Jobs in Echtzeit mit kubectl überwachen können.

Analysieren von Kubernetes-Job-Logs

Die Möglichkeit, die Logs Ihrer Kubernetes-Jobs anzuzeigen und zu analysieren, ist für das Debuggen und das Verständnis des Job-Verhaltens unerlässlich. In diesem Schritt werden wir untersuchen, wie man auf Logs von den von uns erstellten Jobs zugreift und diese analysiert.

Abrufen von Pod-Namen für unsere Jobs

Bevor wir Logs anzeigen können, müssen wir die Namen der von unseren Jobs erstellten Pods kennen. Jeder Job erstellt einen oder mehrere Pods mit Namen, die den Jobnamen und ein zufälliges Suffix enthalten.

Listen wir alle Pods auf, die sich auf unsere Jobs beziehen:

kubectl get pods --show-labels

Dies zeigt Ihnen alle Pods zusammen mit ihren Labels. Suchen Sie nach Pods mit Labels wie job-name=hello-job oder job-name=long-job.

Alternativ können Sie Pods nach Jobnamen filtern:

kubectl get pods -l job-name=hello-job

Dies zeigt nur Pods an, die zum Job hello-job gehören.

Anzeigen von Job-Logs

Nachdem wir nun unsere Pod-Namen kennen, können wir die Logs für unsere Jobs anzeigen. Verwenden Sie den folgenden Befehl und ersetzen Sie <pod-name> durch den tatsächlichen Namen Ihres Pods:

kubectl logs <pod-name>

Wenn Ihr Pod beispielsweise den Namen hello-job-abcd1 hat, würden Sie Folgendes ausführen:

kubectl logs hello-job-abcd1

Sie sollten die Ausgabe sehen:

Hello, Kubernetes!

Dies ist die Nachricht, die unser Job ausgeben sollte.

Überprüfen wir auch die Logs unseres längeren Jobs. Finden Sie zuerst den Pod-Namen:

kubectl get pods -l job-name=long-job

Zeigen Sie dann seine Logs an:

kubectl logs <long-job-pod-name>

Sie sollten sehen:

Starting long job...
Long job completed!

Anzeigen von Logs abgeschlossener Jobs

Einer der Vorteile von Kubernetes-Jobs ist, dass Sie die Logs auch nach Abschluss des Jobs anzeigen können. Dies ist sehr nützlich für Debugging- und Audit-Zwecke.

Erstellen wir einen Job, der fehlschlägt, damit wir sehen können, wie man ihn debuggt:

cd ~/project
nano failed-job.yaml

Kopieren Sie den folgenden YAML-Inhalt und fügen Sie ihn ein:

apiVersion: batch/v1
kind: Job
metadata:
  name: failed-job
spec:
  template:
    spec:
      containers:
        - name: failed
          image: busybox:1.28
          command: ["sh", "-c", 'echo "Attempting task..." && exit 1']
      restartPolicy: Never
  backoffLimit: 2

Dieser Job wird immer mit dem Statuscode 1 beendet, was einen Fehler anzeigt. Speichern Sie die Datei und beenden Sie nano, und erstellen Sie dann den Job:

kubectl apply -f failed-job.yaml

Warten Sie einige Momente, bis der Job versucht hat, ein paar Mal zu scheitern (bis zum Backoff-Limit). Überprüfen Sie dann seinen Status:

kubectl get jobs failed-job

Sie sollten sehen, dass er 0/1 Abschlüsse anzeigt und die Abschlussfrist erreicht hat.

Untersuchen wir nun, was schief gelaufen ist, indem wir die Logs der fehlgeschlagenen Pods überprüfen:

kubectl get pods -l job-name=failed-job

Sie sehen mehrere Pods, alle im Status Error. Wählen Sie einen aus und zeigen Sie seine Logs an:

kubectl logs <failed-pod-name>

Sie sollten sehen:

Attempting task...

Die Pod-Logs zeigen, dass die Aufgabe gestartet wurde, aber dann mit einem Fehlercode beendet wurde. Diese Information ist entscheidend für das Debuggen von Job-Fehlern.

Logs in Echtzeit verfolgen

Wenn Sie die Logs eines laufenden Jobs in Echtzeit verfolgen möchten, können Sie das Flag -f verwenden:

kubectl logs -f <pod-name>

Dies ist besonders nützlich für länger laufende Jobs, bei denen Sie die Ausgabe während der Ausführung sehen möchten.

Erstellen wir einen weiteren langlaufenden Job, um dies zu demonstrieren:

cd ~/project
nano counter-job.yaml

Kopieren Sie den folgenden YAML-Inhalt und fügen Sie ihn ein:

apiVersion: batch/v1
kind: Job
metadata:
  name: counter-job
spec:
  template:
    spec:
      containers:
        - name: counter
          image: busybox:1.28
          command:
            [
              "sh",
              "-c",
              'for i in $(seq 1 5); do echo "Count: $i"; sleep 5; done'
            ]
      restartPolicy: Never

Speichern Sie die Datei und beenden Sie nano, und erstellen Sie dann den Job:

kubectl apply -f counter-job.yaml

Verfolgen wir nun seine Logs. Finden Sie zuerst den Pod-Namen:

kubectl get pods -l job-name=counter-job

Verfolgen Sie dann seine Logs:

kubectl logs -f <counter-job-pod-name>

Sie sehen, wie der Zähler alle 5 Sekunden inkrementiert wird:

Count: 1
Count: 2
Count: 3
Count: 4
Count: 5

Drücken Sie Ctrl+C, um die Verfolgung der Logs zu beenden.

Indem Sie verstehen, wie man auf Logs zugreift und diese analysiert, können Sie Ihre Kubernetes-Jobs effektiv beheben und debuggen.

Erweiterte Job-Überwachungstechniken

Nachdem Sie nun die Grundlagen der Überwachung von Kubernetes-Jobs kennen, wollen wir einige fortgeschrittenere Techniken untersuchen, die Ihnen helfen können, Jobs effektiver zu überwachen, insbesondere in Produktionsumgebungen.

Verwendung von Labels zur Job-Organisation

Labels sind Schlüssel-Wert-Paare, die an Kubernetes-Ressourcen angehängt werden können. Sie sind nützlich für die Organisation und Auswahl von Teilmengen von Ressourcen. Erstellen wir einen Job mit benutzerdefinierten Labels:

cd ~/project
nano labeled-job.yaml

Kopieren Sie den folgenden YAML-Inhalt und fügen Sie ihn ein:

apiVersion: batch/v1
kind: Job
metadata:
  name: labeled-job
  labels:
    department: engineering
    app: demo
    environment: training
spec:
  template:
    spec:
      containers:
        - name: labeled
          image: busybox:1.28
          command: ["sh", "-c", 'echo "This is a labeled job" && sleep 10']
      restartPolicy: Never

Speichern Sie die Datei und beenden Sie nano, und erstellen Sie dann den Job:

kubectl apply -f labeled-job.yaml

Jetzt können Sie Jobs nach ihren Labels filtern:

kubectl get jobs -l department=engineering

Dies zeigt nur Jobs mit dem Label department=engineering an.

Sie können mehrere Labels für eine spezifischere Filterung verwenden:

kubectl get jobs -l department=engineering,environment=training

Überwachen von Job-Events

Kubernetes generiert Events für verschiedene Zustandsänderungen in Ihren Jobs. Diese Events können wertvolle Informationen über den Lebenszyklus Ihrer Jobs liefern.

Zeigen wir die Events an, die sich auf unsere Jobs beziehen:

kubectl get events --sort-by=.metadata.creationTimestamp

Dieser Befehl zeigt alle Events in Ihrem Namespace an, sortiert nach Zeit. Sie können nach Events filtern, die sich auf einen bestimmten Job beziehen:

kubectl get events --field-selector involvedObject.name=labeled-job

Diese Events können Ihnen helfen zu verstehen, wann und warum Jobs erstellt, gestartet oder auf Probleme gestoßen sind.

Verwendung von JSONPath für benutzerdefinierte Ausgabe

Kubernetes ermöglicht es Ihnen, JSONPath zu verwenden, um bestimmte Felder aus der Ausgabe von kubectl-Befehlen zu extrahieren. Dies ist nützlich, um sich auf bestimmte Aspekte Ihrer Jobs zu konzentrieren:

kubectl get job labeled-job -o jsonpath='{.status.succeeded}'

Dieser Befehl gibt die Anzahl der erfolgreichen Pods für den labeled-job aus.

Um die Erstellungszeit eines Jobs abzurufen:

kubectl get job labeled-job -o jsonpath='{.metadata.creationTimestamp}'

Erstellen eines CronJob für die geplante Ausführung

Für Aufgaben, die nach einem Zeitplan ausgeführt werden müssen, bietet Kubernetes CronJobs. Erstellen wir einen einfachen CronJob:

cd ~/project
nano simple-cronjob.yaml

Kopieren Sie den folgenden YAML-Inhalt und fügen Sie ihn ein:

apiVersion: batch/v1
kind: CronJob
metadata:
  name: simple-cronjob
spec:
  schedule: "*/1 * * * *" ## Run every minute
  jobTemplate:
    spec:
      template:
        spec:
          containers:
            - name: hello
              image: busybox:1.28
              command: ["sh", "-c", 'date; echo "Hello from CronJob"']
          restartPolicy: Never

Speichern Sie die Datei und beenden Sie nano, und erstellen Sie dann den CronJob:

kubectl apply -f simple-cronjob.yaml

Überprüfen Sie, ob der CronJob erstellt wurde:

kubectl get cronjobs

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

NAME             SCHEDULE      SUSPEND   ACTIVE   LAST SCHEDULE   AGE
simple-cronjob   */1 * * * *   False     0        <none>          10s

Warten Sie ein oder zwei Minuten und suchen Sie dann nach Jobs, die vom CronJob erstellt wurden:

kubectl get jobs

Sie sollten Jobs mit Namen wie simple-cronjob-<timestamp> sehen.

Um die Logs der letzten CronJob-Ausführung anzuzeigen, finden Sie zuerst den Pod:

kubectl get pods --sort-by=.metadata.creationTimestamp

Zeigen Sie dann seine Logs an:

kubectl logs <latest-cronjob-pod>

CronJobs sind leistungsstark für die Planung wiederkehrender Aufgaben in Ihrem Kubernetes-Cluster, und die gleichen Überwachungstechniken, die wir gelernt haben, können auch auf sie angewendet werden.

Bereinigung

Bevor wir fertig sind, wollen wir die von uns erstellten Ressourcen bereinigen:

kubectl delete job hello-job long-job failed-job counter-job labeled-job
kubectl delete cronjob simple-cronjob

Dadurch werden alle Jobs und der CronJob aus Ihrem Cluster entfernt.

Zusammenfassung

In diesem Tutorial haben Sie gelernt, wie Sie Kubernetes-Jobs effektiv überwachen und deren Logs analysieren können. Sie wissen jetzt, wie man:

• Eine Kubernetes-Umgebung mit Minikube einrichtet
• Kubernetes-Jobs mit verschiedenen Konfigurationen erstellt
• Den Job-Status mit kubectl get und kubectl describe überwacht
• Auf Job-Logs mit kubectl logs zugreift und diese analysiert
• Erweiterte Techniken wie Labels, Events und JSONPath für eine effektivere Überwachung verwendet
• Geplante Jobs mit CronJobs erstellt

Diese Fähigkeiten sind unerlässlich für die Verwaltung containerisierter Anwendungen in einer Kubernetes-Umgebung und ermöglichen es Ihnen, die Zuverlässigkeit und Leistung Ihrer Batch-Prozesse sicherzustellen. Indem Sie verstehen, wie Sie den Job-Fortschritt verfolgen und Probleme durch Logs beheben können, können Sie effiziente und fehlerfreie Kubernetes-Workloads verwalten.

Wenn Sie Ihre Kubernetes-Reise fortsetzen, sollten Sie sich mit fortgeschritteneren Themen wie Ressourcenmanagement, Job-Parallelität und der Integration mit externen Überwachungslösungen wie Prometheus und Grafana beschäftigen.