Chapter 7.4 - CronJobs

Learning Objectives

By the end of this chapter, you will be able to:

Understand what a CronJob is
Create and manage CronJobs
Configure schedules with cron syntax
Handle multiple jobs and timeouts
Understand time zones
Implement scheduled tasks

Introduction

A CronJob creates Jobs on a recurring basis according to a schedule (like cron). It is ideal for scheduled tasks: backups, reports, cleanup, etc.

What is a CronJob?

A CronJob creates Jobs on a recurring basis according to a schedule defined with cron syntax.

Characteristics

Schedule: Standard cron syntax
Job Template: Template for creating Jobs
Concurrency Policy: Handle multiple jobs
Suspend: Pause the CronJob

Cron Syntax

Format

┌───────────── minute (0 - 59)
│ ┌───────────── hour (0 - 23)
│ │ ┌───────────── day of month (1 - 31)
│ │ │ ┌───────────── month (1 - 12)
│ │ │ │ ┌───────────── day of week (0 - 6) (Sunday to Saturday)
│ │ │ │ │
* * * * *

Examples

Schedule	Description
`0 * * * *`	Every hour (at minute 0)
`0 2 * * *`	Every day at 2:00 AM
`/15 * * *`	Every 15 minutes
`0 0 * * 0`	Every Sunday at midnight
`0 9-17 * * 1-5`	Monday to Friday, 9 AM to 5 PM
`0 0 1 * *`	First of every month at midnight

Basic Example

Simple CronJob

apiVersion: batch/v1
kind: CronJob
metadata:
  name: hello-cronjob
spec:
  schedule: "*/1 * * * *"  # Every minute
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: hello
            image: busybox:1.35
            command:
            - /bin/sh
            - -c
            - date; echo "Hello from CronJob"
          restartPolicy: OnFailure
  successfulJobsHistoryLimit: 3
  failedJobsHistoryLimit: 1

Example: Daily Backup

Backup CronJob

apiVersion: batch/v1
kind: CronJob
metadata:
  name: daily-backup
spec:
  schedule: "0 2 * * *"  # Every day at 2:00 AM
  timeZone: "America/New_York"  # Timezone
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: backup
            image: postgres:14
            command:
            - /bin/bash
            - -c
            - |
              echo "Starting backup at $(date)"
              pg_dump -h postgres-service -U postgres mydb > /backup/backup-$(date +%Y%m%d).sql
              gzip /backup/backup-$(date +%Y%m%d).sql
              aws s3 cp /backup/backup-$(date +%Y%m%d).sql.gz s3://backups/
              echo "Backup completed at $(date)"
            env:
            - name: PGPASSWORD
              valueFrom:
                secretKeyRef:
                  name: postgres-secret
                  key: password
            volumeMounts:
            - name: backup-storage
              mountPath: /backup
          volumes:
          - name: backup-storage
            emptyDir: {}
          restartPolicy: OnFailure
  successfulJobsHistoryLimit: 7  # Keep 7 successful backups
  failedJobsHistoryLimit: 3      # Keep 3 failed backups

Concurrency Policy

Controls how to handle multiple jobs:

Allow (Default)

Allows multiple jobs in parallel:

apiVersion: batch/v1
kind: CronJob
metadata:
  name: allow-concurrent
spec:
  schedule: "*/5 * * * *"
  concurrencyPolicy: Allow
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: task
            image: my-app:1.0
          restartPolicy: OnFailure

Forbid

Prevents new jobs if a previous job is still running:

spec:
  concurrencyPolicy: Forbid

Behavior: If a job is still running, the new job is skipped.

Replace

Replaces the previous job with a new one:

spec:
  concurrencyPolicy: Replace

Behavior: The previous job is deleted and a new one is created.

Starting Deadline Seconds

Timeout for starting a job:

apiVersion: batch/v1
kind: CronJob
metadata:
  name: deadline-job
spec:
  schedule: "0 * * * *"
  startingDeadlineSeconds: 300  # 5 minutes
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: task
            image: my-app:1.0
          restartPolicy: OnFailure

Behavior: If a job cannot start within 5 minutes, it is considered missed.

Suspend

Pause a CronJob:

apiVersion: batch/v1
kind: CronJob
metadata:
  name: suspended-job
spec:
  schedule: "0 * * * *"
  suspend: true  # CronJob suspended
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: task
            image: my-app:1.0
          restartPolicy: OnFailure

Via kubectl:

# Suspend
kubectl patch cronjob daily-backup -p '{"spec":{"suspend":true}}'

# Resume
kubectl patch cronjob daily-backup -p '{"spec":{"suspend":false}}'

Job History

Successful Jobs History Limit

Number of successful jobs to retain:

spec:
  successfulJobsHistoryLimit: 3  # Keep 3 successful jobs

Failed Jobs History Limit

Number of failed jobs to retain:

spec:
  failedJobsHistoryLimit: 1  # Keep 1 failed job

Advantages:

View logs of previous jobs
Debug failures
Audit and history

Example: Periodic Cleanup

Cleanup CronJob

apiVersion: batch/v1
kind: CronJob
metadata:
  name: cleanup-old-files
spec:
  schedule: "0 3 * * *"  # Every day at 3:00 AM
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: cleanup
            image: busybox:1.35
            command:
            - /bin/sh
            - -c
            - |
              echo "Cleaning up files older than 30 days"
              find /data -type f -mtime +30 -delete
              find /data -type d -empty -delete
              echo "Cleanup completed"
            volumeMounts:
            - name: data
              mountPath: /data
          volumes:
          - name: data
            persistentVolumeClaim:
              claimName: data-pvc
          restartPolicy: OnFailure
  successfulJobsHistoryLimit: 1
  failedJobsHistoryLimit: 1

Useful Commands

Create and Manage

# Create a CronJob
kubectl apply -f cronjob.yaml

# View CronJobs
kubectl get cronjob
kubectl get cj

# Details
kubectl describe cronjob daily-backup

# View created Jobs
kubectl get jobs -l app=backup

# View Pods
kubectl get pods -l job-name=daily-backup-1234567890

Suspend/Resume

# Suspend
kubectl patch cronjob daily-backup -p '{"spec":{"suspend":true}}'

# Resume
kubectl patch cronjob daily-backup -p '{"spec":{"suspend":false}}'

Delete

# Delete a CronJob
kubectl delete cronjob daily-backup

# Delete with Jobs
kubectl delete cronjob daily-backup --cascade=foreground

Best Practices

1. Appropriate Schedule

Choose a schedule that does not overload the cluster.

2. Concurrency Policy

Use Forbid to avoid conflicts if necessary.

3. Timeouts

Define startingDeadlineSeconds and activeDeadlineSeconds in the Job.

4. History Limits

Configure limits to prevent accumulation of Jobs.

5. Monitoring

Monitor CronJobs to detect failures.

6. Timezone

Specify the timezone if necessary with timeZone.

Summary

In this chapter, you learned:

CronJob: Creates Jobs on a recurring basis according to a schedule
Schedule: Standard cron syntax (minute, hour, day, month, weekday)
Concurrency Policy: Allow, Forbid, Replace
Starting Deadline: Timeout for starting a job
Suspend: Pause a CronJob
Job History: Limits for successful/failed jobs
Use cases: Backups, cleanup, reports, periodic tasks
Best practices: Appropriate schedule, timeouts, monitoring

Next Steps

Module 8: Ingress and Load Balancing
Lab 7.4: Auto-scaling with HPA

Chapter created: December 2024

Learning Objectives​

Introduction​

What is a CronJob?​

Characteristics​

Cron Syntax​

Format​

Examples​

Basic Example​

Simple CronJob​

Example: Daily Backup​

Backup CronJob​

Concurrency Policy​

Allow (Default)​

Forbid​

Replace​

Starting Deadline Seconds​

Suspend​

Job History​

Successful Jobs History Limit​

Failed Jobs History Limit​

Example: Periodic Cleanup​

Cleanup CronJob​

Useful Commands​

Create and Manage​

Suspend/Resume​

Delete​

Best Practices​

1. Appropriate Schedule​

2. Concurrency Policy​

3. Timeouts​

4. History Limits​

5. Monitoring​

6. Timezone​

Summary​

Next Steps​