Learning Kubernetes - Episode 15 - Introduction and Explanation of CronJob

#Introduction

Note

If you want to read the previous episode, you can click the Episode 14 thumbnail below

In the previous episode, we learned about Job, which runs tasks to completion. In episode 15, we'll discuss CronJob, which builds on Job to provide scheduled, recurring task execution.

Note: Here I'll be using a Kubernetes Cluster installed through K3s.

If you're familiar with Unix/Linux cron, CronJob in Kubernetes works similarly - it creates Jobs on a repeating schedule. Think of it as your cluster's task scheduler for automated backups, reports, cleanups, and any recurring operations.

#What Is CronJob?

A CronJob creates Jobs on a time-based schedule. It uses the same cron format as Unix/Linux systems to define when Jobs should run. CronJob manages the lifecycle of Jobs, creating them at scheduled times and cleaning up old Jobs.

Think of CronJob like a cron daemon in Linux - it runs tasks at specified times automatically. In Kubernetes, CronJob creates Job objects on schedule, which then create Pods to execute the actual work.

Key characteristics of CronJob:

Scheduled execution - Runs Jobs at specified times using cron syntax
Recurring tasks - Automatically creates Jobs on schedule
Job management - Manages Job creation and cleanup
Concurrency control - Controls how concurrent Jobs are handled
History limits - Automatically cleans up old Jobs
Timezone support - Can run in specific timezones
Suspend capability - Can pause scheduled execution

#Why Do We Need CronJob?

CronJob is designed for recurring tasks that need to run on a schedule:

Scheduled backups - Daily database backups, weekly full backups
Report generation - Daily reports, monthly summaries
Data cleanup - Remove old logs, temporary files, expired data
Data synchronization - Sync data between systems periodically
Health checks - Periodic system health verification
Certificate renewal - Automated certificate management
Cache warming - Pre-populate caches before peak hours
Batch processing - Process accumulated data at specific times
Monitoring tasks - Periodic checks and alerts

Without CronJob, you would need to:

Manually create Jobs at scheduled times
Set up external schedulers
Manage Job cleanup yourself
Handle timezone conversions manually

#CronJob vs Job

Let's understand the key differences:

Aspect	CronJob	Job
Execution	Scheduled, recurring	One-time
Schedule	Cron syntax	Immediate
Job creation	Automatic on schedule	Manual
Use case	Recurring tasks	One-time tasks
Management	Creates and manages Jobs	Runs Pods directly
Cleanup	Automatic with history limits	Manual or TTL

Example scenario:

CronJob: Run database backup every day at 2 AM
Job: Run database migration once during deployment

#Cron Schedule Syntax

CronJob uses standard cron format with 5 fields:

plaintext

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

#Common Schedule Examples

Every minute:

plaintext

* * * * *

Every hour at minute 0:

plaintext

0 * * * *

Every day at 2:30 AM:

plaintext

30 2 * * *

Every Monday at 9:00 AM:

plaintext

0 9 * * 1

Every 15 minutes:

plaintext

*/15 * * * *

Every 6 hours:

plaintext

0 */6 * * *

First day of every month at midnight:

plaintext

0 0 1 * *

Every weekday at 6:00 PM:

plaintext

0 18 * * 1-5

Every Sunday at 3:00 AM:

plaintext

0 3 * * 0

Twice a day (6 AM and 6 PM):

plaintext

0 6,18 * * *

#Creating a CronJob

Let's create a basic CronJob:

#Example 1: Basic CronJob

Create a file named cronjob-basic.yml:

This CronJob runs every minute.

Apply the configuration:

Verify the CronJob is created:

Or use the shorthand:

Output:

Wait a minute and check the Jobs created:

Output:

Check the Pods:

View logs from a completed Pod:

Output:

#CronJob Concurrency Policy

Control how CronJob handles overlapping executions:

#Allow (Default)

Allows concurrent Jobs to run:

Behavior:

Multiple Jobs can run simultaneously
New Job starts even if previous Job is still running
Good for independent tasks

#Forbid

Prevents concurrent Jobs:

Behavior:

Skips new Job if previous Job is still running
Prevents overlapping executions
Good for tasks that shouldn't run concurrently

#Replace

Replaces currently running Job with new one:

Behavior:

Cancels currently running Job
Starts new Job in its place
Good for tasks where latest execution is most important

#History Limits

Control how many completed and failed Jobs to keep:

This CronJob:

Keeps last 3 successful Jobs
Keeps last 1 failed Job
Automatically deletes older Jobs

Default values:

successfulJobsHistoryLimit: 3
failedJobsHistoryLimit: 1

#Starting Deadline

Set a deadline for starting Jobs:

This CronJob:

Scheduled to run at 2:00 AM
Must start within 1 hour (3600 seconds)
If missed, counts as failed schedule

Use case: If cluster was down during scheduled time, Job can still start when cluster comes back up (within deadline).

#Suspending CronJob

Temporarily pause CronJob execution:

With suspend: true, CronJob won't create new Jobs.

Suspend an existing CronJob:

Resume a suspended CronJob:

#Timezone Support

Specify timezone for schedule (Kubernetes 1.25+):

This runs at 9:00 AM Eastern Time.

Important

Important: Timezone support requires Kubernetes 1.25 or later. Without timeZone field, schedule uses controller manager's timezone (usually UTC).

#Viewing CronJob Details

To see detailed information about a CronJob:

Output:

#Practical Examples

#Example 1: Daily Database Backup

This CronJob:

Runs daily at 2:00 AM UTC
Prevents concurrent backups
Keeps 7 successful backups
Compresses backup files
Stores in persistent volume

#Example 2: Hourly Log Cleanup

This CronJob:

Runs every hour
Deletes logs older than 7 days
Prevents concurrent cleanup operations

#Example 3: Weekly Report Generation

This CronJob:

Runs every Monday at 8:00 AM Eastern Time
Generates weekly reports
Sets resource limits for report generation

#Example 4: Cache Warming

This CronJob:

Runs daily at 6:00 AM
Warms application cache before peak hours
Replaces running Job if new schedule arrives

#Example 5: Certificate Check

This CronJob:

Runs daily at midnight
Checks SSL certificate expiration
Keeps 7 days of history

#Monitoring CronJobs

#Check CronJob Status

#View CronJob Details

#List Jobs Created by CronJob

#Watch CronJob Activity

#Check Last Execution Time

#View CronJob Events

#Common Mistakes and Pitfalls

#Mistake 1: Incorrect Cron Syntax

Problem: Using wrong cron format or invalid values.

Solution: Validate cron syntax before applying:

bash

# Use online cron validators or test locally
# Correct: */5 * * * * (every 5 minutes)
# Wrong: 5 * * * * (at minute 5 of every hour)

#Mistake 2: Not Setting Concurrency Policy

Problem: Multiple Jobs running concurrently when they shouldn't.

Solution: Set appropriate concurrencyPolicy:

#Mistake 3: No History Limits

Problem: Accumulation of old Jobs consuming resources.

Solution: Set history limits:

#Mistake 4: Ignoring Timezone

Problem: Jobs run at wrong times due to timezone confusion.

Solution: Explicitly set timezone (Kubernetes 1.25+):

#Mistake 5: No Starting Deadline

Problem: Missed schedules pile up when cluster recovers.

Solution: Set startingDeadlineSeconds:

#Mistake 6: Not Setting Resource Limits

Problem: CronJob Pods consume excessive resources.

Solution: Always set resource limits in Job template:

#Best Practices

#Use Appropriate Concurrency Policy

Choose based on task requirements:

#Set History Limits

Prevent Job accumulation:

#Configure Starting Deadline

Handle missed schedules gracefully:

#Use Timezone Field

Make schedules explicit (Kubernetes 1.25+):

#Set Job Deadlines

Prevent Jobs from running too long:

#Add Meaningful Labels

Organize and filter CronJobs:

#Use Secrets for Credentials

Never hardcode sensitive data:

#Set Resource Limits

Prevent resource exhaustion:

#Test Schedule Before Production

Verify cron syntax and timing:

#Monitor CronJob Execution

Set up alerts for failed Jobs:

#Deleting CronJobs

#Delete CronJob and Its Jobs

This deletes the CronJob and all Jobs it created.

#Delete CronJob but Keep Jobs

This deletes only the CronJob, leaving Jobs running.

#Troubleshooting CronJobs

#CronJob Not Creating Jobs

Check if CronJob is suspended:

Check schedule syntax:

#Jobs Failing Repeatedly

Check Job logs:

#Too Many Old Jobs

Adjust history limits:

#Conclusion

In episode 15, we've explored CronJob in Kubernetes in depth. We've learned what CronJob is, how it builds on Job to provide scheduled execution, and how to use it for recurring tasks.

Key takeaways:

CronJob creates Jobs on a time-based schedule using cron syntax
Uses standard cron format with 5 fields (minute, hour, day, month, weekday)
Three concurrency policies: Allow, Forbid, Replace
History limits automatically clean up old Jobs
Starting deadline handles missed schedules gracefully
Timezone support available in Kubernetes 1.25+
Can suspend CronJobs to pause execution
Perfect for backups, reports, cleanup, and recurring maintenance
Always set resource limits and history limits
Use appropriate concurrency policy based on task requirements

CronJob is essential for automating recurring tasks in Kubernetes. By understanding CronJob, you can effectively schedule backups, generate reports, clean up resources, and automate maintenance tasks without external schedulers.

Are you getting a clearer understanding of CronJob in Kubernetes? In the next episode 16, we'll discuss Node Selector, a simple mechanism for controlling Pod placement on specific nodes based on labels. Keep your learning momentum going and look forward to the next episode!

Note

If you want to continue to the next episode, you can click the Episode 16 thumbnail below

Episode 16

Learning Kubernetes - Episode 15 - Introduction and Explanation of CronJob

Related Posts