kubernetes cronjob

Introduction

In the world of Kubernetes, automating repetitive tasks is essential for maintaining efficient and reliable operations. Enter Kubernetes CronJobs – a powerful feature that allows you to schedule tasks to run periodically. In this blog, we will explore how CronJobs work, their use cases, and provide detailed examples to help you get started.

What is a Kubernetes CronJob?

A Kubernetes CronJob is a specialized job that runs at scheduled intervals, much like the cron utility in Linux.

Migrating to Kubernetes CronJobs from Linux

It's an excellent tool for tasks such as:

Backing up databases.
Sending periodic notifications.
Cleaning up temporary files or logs.
Generating reports.

CronJobs are defined in YAML manifests and use cron expressions to specify their schedules.

Anatomy of a CronJob Manifest

A basic CronJob YAML manifest consists of the following sections:

Metadata: Defines the name and labels for the CronJob.
Schedule: Specifies the schedule using a cron expression.
Job Template: Defines the tasks to be executed, including the container image and commands.

Here’s a template:

apiVersion: batch/v1
kind: CronJob
metadata:
  name: <cronjob-name>
spec:
  schedule: "<cron-expression>"
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: <container-name>
            image: <image-name>
            args: [<commands>]
          restartPolicy: OnFailure

Example 1: Printing "Hello World"

This simple CronJob runs every minute and logs "Hello World". Create a file helloworld-cj.yaml :

apiVersion: batch/v1
kind: CronJob
metadata:
  name: hello-world-cronjob
spec:
  schedule: "*/1 * * * *" # Runs every minute
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: hello-world
            image: busybox
            args:
            - /bin/sh
            - -c
            - echo "Hello World!"
          restartPolicy: OnFailure

Deploying a CronJob

Apply the CronJob:

I have a namespace test, so will be creating the cronjob there
Use the following command:

kubectl apply -f helloworld-cj.yaml -n test

You can check the cronjob created using this command:

kubcetl get cronjobs -n test

or using K9S

now this cronjob will be triggered every 2 min and a job will be created. This job will run in a k8s pod in the same namespace i.e test

By default, Kubernetes keeps only the three most recent job histories for each CronJob. This is controlled by the successfulJobsHistoryLimit and failedJobsHistoryLimit fields in the CronJob specification.

Check the logs of a running job:
```
 kubectl logs <pod-name>
```
in k9s:

In order to trigger it manually:
Use the following command if you don’t want to wait for the job to schedule on it’s own. Works with kubectl v1.10.1+
the command is:

kubectl create job --from=cronjob/<cronjob-name> <job-name> -n <namespace-name>

Example 2: Daily Backup Task

This CronJob performs a data backup daily at midnight:

apiVersion: batch/v1
kind: CronJob
metadata:
  name: daily-backup
spec:
  schedule: "0 0 * * *" # At midnight
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: backup
            image: your_backup_docker_image
            args:
            - /bin/sh
            - -c
            - "echo 'Performing backup'; sleep 30; echo 'Backup complete!'"
          restartPolicy: OnFailure

Example 3: Weekly Log Cleanup

This CronJob removes old logs every Sunday:

apiVersion: batch/v1
kind: CronJob
metadata:
  name: weekly-log-cleanup
spec:
  schedule: "0 0 * * 0" # Every Sunday
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: log-cleaner
            image: busybox
            env:
            - name: LOG_DIR
              value: "/var/logs"
            args:
            - /bin/sh
            - -c
            - "echo 'Cleaning logs in $LOG_DIR'; rm -rf $LOG_DIR/*"
          restartPolicy: OnFailure

Best Practices for Using CronJobs

Use appropriate schedules: Ensure the cron expression aligns with your task's frequency requirements.
Set resource limits: Prevent resource overuse by defining CPU and memory limits for the containers.
Monitor and log: Use tools like Prometheus or ELK Stack to monitor and analyze CronJob performance.
Handle failures: Set restartPolicy: OnFailure to retry failed jobs.
Cleanup old jobs: Configure .spec.successfulJobsHistoryLimit and .spec.failedJobsHistoryLimit to manage old jobs.

Conclusion

Kubernetes CronJobs are an indispensable feature for automating periodic tasks in your cluster. By understanding their structure and implementing best practices, you can streamline your workflows and focus on more critical aspects of your application.

Happy scheduling!

Create your first Kubernetes CronJob

Table of contents