# Kubernetes CronJob: Aufgaben automatisieren

Kubernetes überwacht aktiv die Ausführung von CronJobs und führt bei auftretenden Fehlern benutzerdefinierte Aktionen aus. Die Konfiguration von Kubernetes CronJobs erfolgt unkompliziert über YAML-Dateien.

## Was ist ein CronJob?

Ein CronJob ist eine Methode zur **Automatisierung von Aufgaben**. Es ist wie ein Wecker, der zu einer bestimmten Uhrzeit klingelt. Ähnlich dazu können Sie einen CronJob so konfigurieren, dass er festgelegte Aufgaben zu vordefinierten Zeiten automatisch ausführt. Ein CronJob kann verschiedene Arten von Aufgaben automatisieren, wie beispielsweise das Aktualisieren von Datenbanken, das Sichern von Dateien, das Ausführen von Skripten oder das Versenden von E-Mails in regelmäßigen Intervallen. Durch die Integration von CronJobs in Kubernetes können Aufgaben überwacht und in Containern isoliert gesteuert werden.

Tipp [Managed Kubernetes](https://cloud.ionos.de/managed/kubernetes "Managed Kubernetes von IONOS") von IONOS bietet Ihnen eine hoch performante Infrastruktur, in der Sie Worker Nodes nach Ihren individuellen Anforderungen konfigurieren können. Die umfassende IONOS Cloud Management-Lösung sorgt für einen reibungslosen Betrieb Ihres Kubernetes-Clusters.

## Kubernetes: CronJob einrichten

Die Erstellung eines CronJobs ähnelt stark der eines regulären Jobs in Kubernetes. Sie müssen dazu eine **YAML-Manifestdatei** anlegen. Hierbei handelt es sich um eine strukturierte Beschreibung, die alle relevanten Details für den CronJob enthält. In dieser Datei werden wichtige Parameter festgelegt, beispielsweise der Zeitplan für die Ausführung des Jobs, die Container sowie die genauen Befehle, die in diesen Containern ausgeführt werden sollen.

### YAML-Datei erstellen

Öffnen Sie einen Texteditor Ihrer Wahl, um die YAML-Konfigurationsdatei für den CronJob zu erstellen. Achten Sie darauf, den Zeitplan des CronJobs im **Cron-Format** zu definieren. Fügen Sie die Job-Definition hinzu, einschließlich der auszuführenden Aufgabe. Speichern Sie dann die Datei mit der Endung `.yaml`.

```yaml
apiVersion: batch/v1
kind: CronJob
metadata:
    name: new_cronjob
spec:
    schedule: "0     ****    "
    jobTemplate:
        spec:
            template:
                spec:
                    containers:
                    - name: container
                        image: image:latest
                        command: 
                     - /bin/sh
```

Fügen Sie der **Pod-Spezifikation** Ressourcenanforderungen und andere Einstellungen hinzu, falls erforderlich:

```yaml
spec:
    containers:
    - name: container
        resources:
            requests:
                memory: "64Mi"
                cpu: "250m"
            limits:
                memory: "128Mi"
                cpu: "500m"
```

### CronJob aktivieren

Geben Sie folgenden Befehl in ein Terminal ein, um den CronJob im Kubernetes-Cluster zu erstellen:

```shell
kubectl apply -f [filename].yaml
```

### CronJob überwachen

Wenn Sie folgendes Kommando ausführen, erhalten Sie eine Liste der vorhandenen Kubernetes CronJobs und der **Watch-Modus** sorgt dafür, dass die Ausgabe automatisch aktualisiert wird, wenn sich der Status von CronJobs ändert.

```shell
kubectl get cronjob --watch
```

### CronJob Schedule-Syntax

Die **Schedule-Syntax** für Kubernetes CronJobs basiert auf dem klassischen Cron-Format mit fünf Feldern in folgender Reihenfolge: Minute, Stunde, Tag des Monats, Monat und Tag der Woche. Hier ein kurzer Überblick:

- Minute (0–59)
- Stunde (0–23)
- Tag des Monats (1–31)
- Monat (1–12 oder Jan–Dec)
- Tag der Woche (0–7 oder Sun–Sat)

Spezielle Zeichen:

- `*`: Jeder gültige Wert für das Feld
- `,`: Angabe von mehreren Werten
- `/`: Angabe von Schritten

Beispiele:

`0   ****`: Jede Stunde `15 2  ***`: Täglich um 2:15 Uhr `0 0 1  **`: Am ersten Tag jedes Monats um Mitternacht `0 0  *3*`: Täglich um Mitternacht im März `0 2  **  1`: Jeden Montag um 2 Uhr morgens

### CronJob Concurrency Policy

Die Concurrency Policy kann in der Konfiguration eines CronJobs spezifiziert werden und hat Auswirkungen darauf, wie parallele Jobs innerhalb desselben Kubernetes CronJobs behandelt werden.

- **Allow (Standard)**: Wenn die Concurrency Policy auf `__Allow__` gesetzt ist, wird ein neuer Job gestartet, auch wenn der vorherige Job noch nicht abgeschlossen ist. Das bedeutet, dass mehrere Instanzen desselben Jobs gleichzeitig laufen können.
- **Forbid**: Bei dieser Einstellung wird ein neuer Job nicht gestartet, wenn ein vorheriger Job noch nicht abgeschlossen ist. Dies stellt sicher, dass zu einem bestimmten Zeitpunkt nur eine Instanz des Jobs ausgeführt wird.
- **Replace**: Nicht abgeschlossene Jobs werden abgebrochen, damit neue Jobs fortfahren können. Es dürfen keine Instanzen desselben Jobs gleichzeitig laufen.

### Frist für die Ausführung festlegen

Das Feld `startingDeadlineSeconds` in einem Kubernetes CronJob gibt an, wie viele Sekunden nach der geplanten Ausführungszeit ein Job maximal gestartet werden darf. Wenn der Job nicht innerhalb dieser Zeitgrenze läuft, wird er als **fehlgeschlagen** betrachtet.

```yaml
apiVersion: batch/v1
kind: CronJob
metadata:
    name: new_cronjob
spec:
    schedule: "0     ****    "
    startingDeadlineSeconds: 300 
    jobTemplate:
        spec:
            template:
                spec:
                    containers:
                    - name: container
                        image: image:latest
                        command:
                     - /bin/sh
```

In diesem Beispiel muss der Job, der durch den CronJob definiert ist, innerhalb von 300 Sekunden (5 Minuten) nach dem geplanten Zeitpunkt gestartet werden, sonst gilt er als fehlgeschlagen.

### Job-Historie begrenzen

In Kubernetes CronJobs bieten die Einstellungen `spec.successfulJobsHistoryLimit` und `spec.failedJobsHistoryLimit` die Möglichkeit, die Anzahl der im Verlauf des CronJobs aufbewahrten Jobs zu begrenzen. `spec.successfulJobsHistoryLimit` ist ein optionales Feld, das angibt, wie viele erfolgreich abgeschlossene Jobs im Verlauf gespeichert werden sollen. Das ist hilfreich, um die **Ressourcennutzung zu steuern** und sicherzustellen, dass der Verlauf nicht mit einer übermäßigen Anzahl von erfolgreich beendeten Jobs überfüllt wird. Analog dazu ermöglicht `spec.failedJobsHistoryLimit` die Kontrolle über die Anzahl der fehlgeschlagenen Jobs.

```yaml
apiVersion: batch/v1beta1
kind: CronJob
metadata:
    name: new_cronjob
spec:
    schedule: "0     ****    "
    successfulJobsHistoryLimit: 3    # Keep only the last 3 successfully completed jobs in history.
    failedJobsHistoryLimit: 1                    # Keep only the last failed job in history.
    jobTemplate:
        spec:
            template:
                spec:
                    containers:
                    - name: container
                        image: image:latest
                        command:
                     - /bin/sh
```

Hier geben wir an, nur die letzten drei erfolgreich abgeschlossenen Jobs und den letzten fehlgeschlagenen Job im Verlauf des Kubernetes CronJobs `new_cronjob` aufzubewahren.

## Kubernetes Cronjob Errors und Troubleshooting

In Kubernetes CronJobs können verschiedene Fehler auftreten, daher sollten Sie effektive **Troubleshooting-Techniken** kennen. Hier sind einige häufige Fehlerquellen und Vorgehensweisen zur Behebung:

### Job startet nicht

Wenn ein CronJob in Kubernetes nicht gestartet wird, kann dies verschiedene Ursachen haben. Möglich sind ein nicht verfügbares oder **fehlerhaftes Container-Image** sowie fehlende Berechtigungen für den Service-Account des Pods. Um das Problem zu diagnostizieren, untersuchen Sie die Container-Logs mit `kubectl logs <pod-name>`, die Ereignisse des CronJobs mit `kubectl describe cronjob <cronjob-name>`, und die Ereignisse des Pods mit `kubectl describe pod <pod-name>`. Stellen Sie sicher, dass der Service-Account die notwendigen Berechtigungen hat, indem Sie die Rolle und Rollenbindung überprüfen.

### Fehlerhafte CronJob-Konfiguration

Eine fehlerhafte CronJob-Konfiguration kann an **Syntaxfehlern in der YAML-Datei** oder ungültigen Einstellungen für Schedule und RestartPolicy liegen. Um solche Probleme zu identifizieren, kontrollieren Sie die YAML-Datei auf korrekte Syntax und Einstellungen. Mit `kubectl describe cronjob <cronjob-name>` können Sie detaillierte Informationen über die Konfiguration erhalten und eventuelle Fehler oder Unstimmigkeiten erkennen.

### Ressourcenlimits überschritten

Das Überschreiten von Ressourcenlimits kann dazu führen, dass CronJobs nicht ordnungsgemäß ausgeführt werden. Um das Problem zu beheben, überprüfen Sie die Ressourcenlimits im CronJob und den zugehörigen Pods mit `kubectl describe cronjob <cronjob-name>` und `kubectl describe pod <pod-name>`. Zudem kann die **Überwachung der Cluster-Ressourcennutzung** mit `kubectl top nodes` und `kubectl top pods` wertvolle Einblicke liefern. Passen Sie gegebenenfalls die Ressourcenlimits in der YAML-Datei an.

Als Einstieg in das Cluster-Management in Kubernetes empfehlen wir Ihnen das [Kubernetes-Tutorial](https://www.ionos.at/digitalguide/server/konfiguration/kubernetes-tutorial/) aus unserem Digital Guide.


This is a markdown version of: [https://www.ionos.at/digitalguide/server/konfiguration/kubernetes-cronjob/](https://www.ionos.at/digitalguide/server/konfiguration/kubernetes-cronjob/) for AI/LLM consumption.