Jobs and CronJobs for batch processing in Kubernetes - Step-by-Step Execution

Process Flow - Jobs and CronJobs for batch processing

Define Job or CronJob YAML

↓

kubectl apply -f file.yaml

↓

Kubernetes creates Job resource

↓

Job creates Pod(s) to run batch task

↓

Pod runs task to completion

↓

Job marks completion or failure

↓

For CronJob: Wait until next schedule

↓

Repeat Job creation on schedule

Shows how defining and applying a Job or CronJob YAML leads Kubernetes to create Pods that run batch tasks once or on a schedule.

Execution Sample

Kubernetes

apiVersion: batch/v1
kind: Job
metadata:
  name: example-job
spec:
  template:
    spec:
      containers:
      - name: batch
        image: busybox
        command: ["/bin/sh", "-c", "echo Hello; sleep 5"]
      restartPolicy: Never

This Job runs a simple batch task that prints 'Hello' and sleeps for 5 seconds, then completes.

Process Table

Step	Action	Resource State	Pod State	Output/Result
1	Apply Job YAML with kubectl	Job resource created	No Pod yet	Job registered in cluster
2	Kubernetes creates Pod for Job	Job active	Pod Pending	Pod scheduled to node
3	Pod starts container	Job active	Pod Running	Container runs command
4	Container executes 'echo Hello'	Job active	Pod Running	Output: Hello
5	Container sleeps 5 seconds	Job active	Pod Running	Waiting...
6	Container finishes command	Job succeeded	Pod Succeeded	Pod completes successfully
7	Job marks completion	Job completed	Pod terminated	Batch task done
8	For CronJob: Wait for next schedule	CronJob active	No Pod	Next Job will start later
9	Exit	No new Pods until schedule	No Pod	Waiting for next run

💡 Job completes when Pod finishes successfully; CronJob waits for next scheduled time to create new Job

Status Tracker

Variable	Start	After Step 2	After Step 4	After Step 6	Final
Job Status	Not created	Active	Active	Succeeded	Completed
Pod Status	None	Pending	Running	Succeeded	Terminated
Output	None	None	"Hello"	None	None

Key Moments - 3 Insights

Why does the Pod start in Pending state before Running?

The Pod is first scheduled to a node (Pending) before the container starts running (Running), as shown in execution_table step 2 and 3.

What happens if the container command fails?

The Job will mark failure and may retry depending on spec; this differs from the successful completion shown in step 6 and 7.

How does CronJob differ from Job in execution?

CronJob creates Jobs on a schedule repeatedly, waiting between runs as shown in steps 8 and 9, unlike a single Job that runs once.

Visual Quiz - 3 Questions

Look at the execution table, what is the Pod state at step 4?

A Pending

B Running

C Succeeded

D Terminated

💡 Hint

Check the 'Pod State' column at step 4 in the execution_table.

At which step does the Job mark completion?

A Step 5

B Step 6

C Step 7

D Step 8

💡 Hint

Look for 'Job marks completion' in the 'Action' column of execution_table.

If the container command took longer to run, which step would be delayed?

A Step 6 Container finishes command

B Step 3 Pod Running

C Step 5 Container sleeps

D Step 4 Container executes command

💡 Hint

Longer command execution affects when the container finishes, shown in step 6.

Concept Snapshot

Jobs run batch tasks once by creating Pods that execute commands to completion.
CronJobs schedule Jobs repeatedly at set times.
Apply YAML with kubectl to create Jobs or CronJobs.
Pods start Pending, then Running, then Succeeded or Failed.
Job status updates track Pod completion.
CronJobs wait between runs to create new Jobs.

Full Transcript

This visual execution shows how Kubernetes Jobs and CronJobs work for batch processing. First, you define a Job or CronJob in YAML and apply it with kubectl. Kubernetes creates a Job resource, which then creates a Pod to run the batch task. The Pod starts in Pending state while scheduled, then moves to Running as the container executes the command. The example command prints 'Hello' and sleeps for 5 seconds. After the container finishes, the Pod status changes to Succeeded and the Job marks completion. For CronJobs, after one Job finishes, Kubernetes waits until the next scheduled time to create a new Job and Pod, repeating the process. This step-by-step flow helps beginners see how batch tasks run once or on a schedule in Kubernetes.