Kubernetes CronJob not running: what to check and how to start it manually
Updated 15 November 2026
A CronJob creates a Job at each scheduled time. The Job creates a pod, which hosts the container that runs the command. When a CronJob “doesn’t run”, first identify where the process stopped: was the job never created, did the pod fail to start, or did the command fail? The examples use a CronJob called backup; replace it with your CronJob’s name. If it is in another namespace, add -n <namespace> to the commands and replace <namespace> with that namespace’s name.
1. Did it create a job?
kubectl get cronjob backup
kubectl get jobs --sort-by=.metadata.creationTimestamp
kubectl describe cronjob backup
kubectl get cronjob shows the schedule, whether it’s suspended (SUSPEND), how many jobs are running (ACTIVE) and how long ago it created the last one (LAST SCHEDULE). kubectl describe ends with the events of the CronJob, where the controller says what it did and why.
Job names include the CronJob’s name and a numeric suffix; for example, backup-29911860. If there’s no job for the time you expected, go through steps 2 to 5. If there is one, go to step 6.
2. Is it suspended?
With spec.suspend: true, the CronJob keeps its schedule but stops creating jobs. This option may have been enabled manually during an incident or through a Helm chart’s configuration. To resume creating jobs:
kubectl patch cronjob backup -p '{"spec":{"suspend":false}}'
The runs it skipped while suspended count as missed. If the CronJob has no startingDeadlineSeconds, it starts a job for the most recent one right away when you turn it back on.
3. Is the schedule in the time zone you think?
Without spec.timeZone, the schedule uses the time zone of the cluster’s kube-controller-manager component. This is usually UTC; in that case, 0 3 * * * schedules a run for 3:00 UTC. To specify another time zone:
spec:
schedule: "0 3 * * *"
timeZone: "America/Santiago"
timeZone is stable since Kubernetes 1.27. A zone written in the schedule, like CRON_TZ=America/Santiago 0 3 * * *, isn’t supported: Kubernetes rejects it when you create or update the CronJob.
The schedule has the five fields of a crontab, with steps like */5, and it accepts @hourly, @daily, @weekly, @monthly and @yearly. Paste it in the cron expression tester to see when it runs next in your time zone. More in the time zone of cron.
4. Did it miss its deadline to start?
spec.startingDeadlineSeconds is how late a job can start. If the CronJob can’t create it within those seconds of the scheduled time, because the controller was down or the previous run was still going, it skips that run and waits for the next.
- A very short deadline skips runs. With less than 10 seconds the job may never be created: the controller checks the CronJobs every 10 seconds.
- Without it, there’s no deadline: a job that couldn’t start on time starts when it can.
-
After a long time without running, only the last one runs. If the CronJob missed more than 100 runs, it records a
TooManyMissedTimesevent and starts one job, for the most recent. In older versions of Kubernetes it stopped creating jobs instead, with the errortoo many missed start time (> 100), until you setstartingDeadlineSeconds.
5. Is the previous run still going?
spec.concurrencyPolicy says what to do when it’s time for a run and the previous one hasn’t finished:
-
Allow, the default, starts it anyway. Runs that take longer than the interval pile up. -
Forbidskips the new one. A job that hangs blocks every run after it:ACTIVEstays at 1, andLAST SCHEDULEstops moving. -
Replacestops the one that’s running and starts the new one.
With Forbid, you can delete the stuck job with kubectl delete job <job-name>. To prevent this from happening again, set activeDeadlineSeconds under the CronJob’s spec.jobTemplate.spec. If a job exceeds that time limit, Kubernetes stops its pods and marks it as failed. To prevent overlapping runs in a crontab, see the flock guide.
6. The job exists, but the pod doesn’t start or fails
Replace backup-29911860 with the name of the job you want to inspect and <pod> with its pod’s name:
kubectl get pods --selector=job-name=backup-29911860
kubectl describe pod <pod>
kubectl logs job/backup-29911860
The status of the pod says where it stopped:
-
ImagePullBackOfforErrImagePull: the image doesn’t exist with that name and tag, or the secret to pull it from the registry is missing. -
Pending: no node has room for it, or none matches its node selector or its tolerations. The events inkubectl describe podsay which. -
CreateContainerConfigError: it refers to aSecretor aConfigMapthat doesn’t exist in the namespace. -
Error: the command ran and failed.kubectl logsshows its output, andkubectl describe podits exit code: what each one means is in cron job exit codes. With 137 and the reasonOOMKilled, it went over its memory limit.
A job retries a pod that fails: 6 times unless you set another backoffLimit, waiting longer each time, and then it’s marked as failed. The pod’s restartPolicy has to be Never or OnFailure.
Deleting an old job also removes its pods and the logs available through kubectl logs. By default, a CronJob keeps the last 3 successful jobs and the last failed job. To retain more history, increase successfulJobsHistoryLimit and failedJobsHistoryLimit.
Run it now
kubectl create job creates a job with the CronJob’s template, without waiting for its schedule. It works on a suspended CronJob too:
kubectl create job --from=cronjob/backup backup-manual
kubectl wait --for=condition=complete job/backup-manual --timeout=10m
kubectl logs job/backup-manual
kubectl delete job backup-manual
kubectl wait returns when the job completes successfully. If the job fails, the command keeps waiting until the timeout; you can check its status with kubectl get job backup-manual from another terminal. The name must be unique within the namespace: delete the job when you’re done inspecting it, or use another name next time.
A change to the CronJob applies to the jobs it creates from then on, not to the ones already running.
Know when it doesn’t run
Kubernetes notifies nobody when a job fails, and a CronJob that stays suspended or misses its runs leaves no failed job to look at. To find out, the job has to report each run to a monitor that expects it: when it starts, and how it ends. With CronDrive, wrap the command with two calls:
apiVersion: batch/v1
kind: CronJob
metadata:
name: backup
spec:
schedule: "0 3 * * *"
timeZone: "America/Santiago"
concurrencyPolicy: Forbid
startingDeadlineSeconds: 600
jobTemplate:
spec:
activeDeadlineSeconds: 3600
template:
spec:
restartPolicy: Never
containers:
- name: backup
image: registry.example.com/backup:1.4
command:
- /bin/sh
- -c
- |
url=https://job.crondrive.com/<token>
curl -fsS -m 10 "$url/start/$HOSTNAME"
/app/backup.sh
code=$?
curl -fsS -m 10 "$url/end/$code/$HOSTNAME"
exit $code
$HOSTNAME identifies the pod and pairs its start notification with its end notification. exit $code returns the command’s exit code to Kubernetes. The image must include curl. When the job retries, each pod reports its own run.
Create the job in CronDrive with the same schedule and time zone as the CronJob. CronDrive alerts you if a run fails, doesn’t start within the grace period, or exceeds the time limit you set for completion. This helps you detect a suspended CronJob, a pod that can’t pull its image, or a job that never finishes.