Kubernetes CronJob Not Running? A Troubleshooting Checklist
Contents
When a Kubernetes CronJob doesn't run, the failure sits at one of three levels: the CronJob controller never created a Job, the Job never got a running Pod, or the Pod ran and failed. kubectl get cronjob and the CronJob's events tell you which level, and the Job's and Pod's events tell you why. Start at the top and work down; most causes leave a specific event behind, as long as you look within an hour.
This checklist covers batch/v1 CronJobs on Kubernetes 1.27 and later, checked against the CronJob and Job documentation on November 16, 2026. For metrics, Prometheus rules, and a full monitoring setup, see Kubernetes CronJob monitoring.
Find the Level That Failed#
A CronJob is a template plus a schedule. The CronJob controller in kube-controller-manager creates a Job at each scheduled time, the Job controller creates Pods, and the kubelet runs the container. Each step can stop the run.
kubectl get cronjob nightly-report # SUSPEND, ACTIVE, LAST SCHEDULE
kubectl describe cronjob nightly-report # spec, active Jobs, recent events
kubectl events --for cronjob/nightly-report # events recorded on the CronJob
kubectl get jobs --watch # Jobs as they are created and finish| What you see | Likely cause | Section |
|---|---|---|
SUSPEND is True |
The CronJob is suspended | 1 |
MissSchedule events, LAST SCHEDULE falls behind |
startingDeadlineSeconds too short |
2 |
TooManyMissedTimes warning |
More than 100 missed start times | 3 |
JobAlreadyActive events, ACTIVE stays at 1 |
concurrencyPolicy: Forbid and a stuck Job |
4, 5 |
| Runs start but never finish | Replace kills them, or the Job is stuck |
4, 5 |
| It runs, but hours off | The schedule is read in another time zone | 6 |
| No events at all, nothing scheduled anywhere | Controller or clock problem | 7 |
Job exists, no Pod, FailedCreate on the Job |
Quota, LimitRange, or admission policy | 8 |
Pod Pending, ErrImagePull, or ImagePullBackOff |
Scheduling or image problem | 8 |
| Pod ran and failed | The job itself; see its logs and exit code | 9 |
Kubernetes events are kept for one hour by default (the kube-apiserver --event-ttl flag), so a 2 AM failure checked at 9 AM may have left nothing to read. To reproduce a run on demand, create a Job from the template:
kubectl create job nightly-report-manual --from=cronjob/nightly-reportThat tests the template, image, and Pod, but not the schedule or the controller, so it can succeed while scheduled runs still don't happen.
1. The CronJob Is Suspended#
.spec.suspend: true stops new runs. The docs are precise: suspended executions "remain scheduled, but the CronJob controller does not start the Jobs," and Jobs already started keep running (schedule suspension). A CronJob suspended during an incident, by a Helm value, or by a GitOps overlay for a staging cluster stays quiet indefinitely, and nothing records that it's quiet.
kubectl get cronjobs -A -o custom-columns=\
NS:.metadata.namespace,NAME:.metadata.name,SUSPEND:.spec.suspend,LAST:.status.lastScheduleTime
kubectl patch cronjob nightly-report -p '{"spec":{"suspend":false}}'Unsuspending has a side effect. Suspended executions count as missed Jobs, and when suspend goes from true to false on a CronJob without a starting deadline, "a Job for the most recent missed schedule is started immediately." Earlier missed schedules don't run. If an immediate run would be wrong, such as a billing job at noon, set startingDeadlineSeconds before unsuspending so the stale run is skipped.
If your deployment tool owns the manifest, a kubectl patch will be reverted on the next sync. Fix the value in the source.
2. startingDeadlineSeconds Is Too Short#
startingDeadlineSeconds is how late a run may start. If the controller can't create the Job within that many seconds of its scheduled time, it skips that run and records a MissSchedule event; future runs are still scheduled (starting deadline). Unset means no deadline.
A short deadline turns any delay into a skipped run: a controller restart, leader election during an upgrade, or a previous run still active under Forbid. The docs add a hard floor: below 10 seconds the CronJob "may not be scheduled," because the controller checks every 10 seconds.
kubectl get cronjob nightly-report -o jsonpath='{.spec.startingDeadlineSeconds}{"\n"}'
kubectl events --for cronjob/nightly-report | grep -i missPick a deadline you'd accept as late, not the tightest value that usually works: for a nightly job, 600 or 3600 seconds is reasonable. The deadline is still useful, because without one a run delayed by hours starts whenever the controller gets to it.
3. "Too Many Missed Start Times"#
At each check, the controller counts the schedules it missed since the last scheduled time. If there are more than 100, it records a TooManyMissedTimes warning:
too many missed start times. Set or decrease .spec.startingDeadlineSeconds or check clock skewOn current Kubernetes, this does not stop the CronJob. The controller "still starts a Job for the most recent missed schedule," and the earlier ones are never started (CronJob limitations). Advice to delete and recreate the CronJob comes from the controller that Kubernetes replaced in 1.21.
You get here when a frequent schedule meets a long gap: a * * * * * CronJob that was suspended for two hours, a controller down overnight, or a clock that jumped. With startingDeadlineSeconds set, the controller counts only misses inside that window: at 200 seconds, a one-minute schedule can miss at most three. So the fix the message suggests is the right one, and it also stops a long outage from producing a surprise catch-up run.
4. concurrencyPolicy Holds or Kills Runs#
concurrencyPolicy decides what happens when a run is due and the previous Job hasn't finished (concurrency policy):
| Policy | When the previous Job is still active | What it looks like |
|---|---|---|
Allow (default) |
Starts another Job alongside it | Overlapping runs, rarely "not running" |
Forbid |
Skips the new run; JobAlreadyActive event |
Runs stop while one Job hangs |
Replace |
Deletes the running Job and starts a new one | Runs start but never finish |
Forbid is the usual cause of "it ran once and then stopped." One Job hangs, every later run is held, and ACTIVE stays at 1. When that Job finally finishes, startingDeadlineSeconds is still applied, so a held run may start late or be skipped. Under Forbid, a held run also counts as missed toward the 100-schedule check.
Replace hides the opposite problem. A job that takes 70 minutes on an hourly schedule is killed every hour and never completes, while kubectl get jobs shows a fresh Job each time. If the work can't finish within one interval, either the interval or the job has to change.
kubectl get cronjob nightly-report -o jsonpath='{.spec.concurrencyPolicy}{" "}{.status.active}{"\n"}'5. A Job Is Stuck Active#
A Job stays active while it has Pods that haven't succeeded and it hasn't hit a limit. Find the active Job and look at its Pods:
kubectl get jobs --sort-by=.metadata.creationTimestamp
kubectl describe job nightly-report-29384750
kubectl get pods -l batch.kubernetes.io/job-name=nightly-report-29384750
kubectl logs -l batch.kubernetes.io/job-name=nightly-report-29384750 --tail=50The usual reasons:
- The process never exits. A hung network call, a lock wait, or a worker that keeps a non-daemon thread alive. The Pod shows
Runningfor hours. - The Pod never starts.
Pendingwith aFailedSchedulingevent, or an image that can't be pulled (section 8). The Job stays active the whole time. - Retries in progress. With
restartPolicy: OnFailure, the container restarts in place and the Pod'sRESTARTScount climbs; withNever, the Job creates new Pods with a growing back-off delay untilbackoffLimit(default 6) is reached.
Give every scheduled Job an upper bound with activeDeadlineSeconds in the jobTemplate.spec. Once a Job reaches it, its running Pods are terminated and the Job fails with reason DeadlineExceeded; it takes precedence over backoffLimit (Job termination). Set it on the Job spec, not the Pod spec, which has a field with the same name. Kubernetes CronJob failure handling covers retries and deadlines in depth.
6. It Runs at the Wrong Time#
Without .spec.timeZone, kube-controller-manager reads the schedule in its own local time zone, which on a managed cluster you usually can't see. 0 2 * * * might mean 02:00 UTC when you meant 02:00 in Chicago, which looks like a job that "didn't run" when you checked at 03:00 local time.
kubectl get cronjob nightly-report -o jsonpath='{.spec.schedule}{" "}{.spec.timeZone}{"\n"}'
kubectl get cronjob nightly-report -o jsonpath='{.status.lastScheduleTime}{"\n"}'lastScheduleTime is an RFC 3339 timestamp in UTC, so compare it with the hour you expected in UTC. Set .spec.timeZone to an IANA name such as America/Chicago (stable since 1.27). CRON_TZ= or TZ= inside .spec.schedule fails validation on new CronJobs. Daylight saving time can also skip a run or double it on transition nights; cron and daylight saving time traces what the controller does.
7. The Controller or the Clock#
If no CronJob in the cluster is creating Jobs, the problem is the controller, not your spec. On a self-managed cluster, check that kube-controller-manager is running and holds its leader lease:
kubectl -n kube-system get pods -l component=kube-controller-manager
kubectl -n kube-system get lease kube-controller-manager -o jsonpath='{.spec.holderIdentity}{"\n"}'
kubectl -n kube-system logs -l component=kube-controller-manager --tail=200 | grep -i cronjobThe component=kube-controller-manager label is what kubeadm sets on its static Pod; other installers differ, and on managed services the control plane isn't visible at all, so check the provider's control-plane logs or status page.
Clock skew shows up in the "too many missed start times" message for a reason: the controller compares scheduled times with its own clock. A control-plane node whose clock jumped forward sees many missed schedules at once; one that runs behind creates Jobs late. Check that time synchronization is running on control-plane nodes.
Two documented quirks are not bugs to chase. Scheduling is "approximate": in some circumstances "two Jobs might be created, or no Job might be created," which is why the docs ask for idempotent Jobs. And edits to a CronJob apply only to Jobs created afterward; a running Job keeps the old template.
8. The Job Can't Create a Running Pod#
If a Job exists but its Pods don't, read the Job's events:
kubectl describe job nightly-report-29384750 | sed -n '/Events:/,$p'
kubectl get events --field-selector involvedObject.name=nightly-report-29384750A FailedCreate event with a message like pods "..." is forbidden: exceeded quota means a ResourceQuota in the namespace has no room. A LimitRange or an admission webhook (Pod Security admission, Kyverno, Gatekeeper) can reject the Pod the same way, with its reason in the message. The CronJob controller can also record FailedCreate on the CronJob when it can't create the Job itself, for example because a quota on Job objects or an admission policy rejects it.
If the Pod exists but doesn't run, read the Pod's events:
| Pod status / event | Meaning |
|---|---|
Pending, FailedScheduling |
No node fits: CPU, memory, taints, node selectors |
ErrImagePull, ImagePullBackOff |
Wrong tag, missing registry credentials, rate limit |
CreateContainerConfigError |
A referenced Secret or ConfigMap is missing |
OOMKilled in the last state |
The container exceeded its memory limit |
Image problems are common after a CI change: a tag that was never pushed, an imagePullSecrets entry that exists in one namespace but not this one, or a public registry's pull rate limit hit at midnight when every CronJob in the cluster starts at once.
9. The Pod Ran and Failed#
If a Pod ran, the CronJob did its part. Read the logs, including the previous container attempt when restartPolicy: OnFailure restarted it, and the exit code:
kubectl logs nightly-report-29384750-x7k2p --previous
kubectl get pod nightly-report-29384750-x7k2p \
-o jsonpath='{range .status.containerStatuses[*]}{.name}{" "}{.state.terminated.exitCode}{" "}{.lastState.terminated.exitCode}{" "}{.lastState.terminated.reason}{"\n"}{end}'With failedJobsHistoryLimit at its default of 1, only the most recent failed Job is kept, so the evidence for older failures is deleted with the Job. Raise it, or ship logs off the cluster.
Get Told When a CronJob Doesn't Run#
Every section above starts after someone noticed. Kubernetes records what happened as status and short-lived events; it doesn't notify anyone, and when the controller or the cluster is the thing that broke, there's nothing inside it to raise the alarm. An external check that knows when each run is due catches all nine causes the same way: no report arrives.
There's no CronRadar integration for Kubernetes and no discovery of CronJobs; each CronJob reports over HTTP from its container, with a monitor key and schedule per job. The container reports start, runs the job, reports complete or fail, and exits with the job's own code:
command:
- /bin/sh
- -c
- |
report() {
event=$1
shift
curl --fail --silent --show-error --max-time 5 --output /dev/null \
--request POST --get --user "$CRONRADAR_API_KEY:" \
--data-urlencode "schedule=0 2 * * *" \
--data-urlencode "run_id=$RUN_ID" \
"$@" "https://cron.life/api/v1/ping/nightly-report/$event" || true
}
report start
/app/nightly-report
rc=$?
if [ "$rc" -eq 0 ]; then
report complete
else
report fail --data-urlencode "message=nightly-report exited with code $rc"
fi
exit "$rc"CRONRADAR_API_KEY comes from a Secret and RUN_ID from the Pod's batch.kubernetes.io/job-name label through the downward API; the monitoring guide has the full manifest. Because every report carries the schedule, the first run creates the monitor. After the expected time plus the grace period with no report, the monitor goes from warning to critical and alerts by email, Slack, webhook, Discord, or PagerDuty. A fail report alerts immediately, and a start with no finish, such as a Pod killed by activeDeadlineSeconds, is flagged as stuck.
CronRadar evaluates schedules in the application's time zone, an IANA name set in the application's settings (UTC when unset). Set it to the CronJob's timeZone, or write both in UTC. One limit to know: a monitor that creates itself from its first report can't alert on a CronJob that has never run. For a new CronJob, create the monitor first in the dashboard so it starts pending and alerts if the first run never checks in.
Frequently Asked Questions#
Why is my Kubernetes CronJob not creating Jobs?#
Check kubectl get cronjob for SUSPEND set to True, then the CronJob's events for MissSchedule, JobAlreadyActive, or TooManyMissedTimes. A suspended CronJob, a Forbid policy behind a stuck Job, and a short startingDeadlineSeconds cover most cases. If no CronJob in the cluster is creating Jobs, look at kube-controller-manager.
What does "too many missed start times" mean?#
The controller found more than 100 missed schedules since the last scheduled time, usually after a suspension, an outage, or a clock jump on a frequent schedule. Current Kubernetes still starts a Job for the most recent missed schedule and skips the rest. Setting startingDeadlineSeconds limits the count to misses inside that window.
Why did my CronJob run immediately after I unsuspended it?#
Suspended executions count as missed. Without a starting deadline, unsuspending starts a Job for the most recent missed schedule right away. Set startingDeadlineSeconds before unsuspending if that run would be stale.
How do I test a CronJob without waiting for the schedule?#
kubectl create job test-run --from=cronjob/nightly-report creates a Job from the CronJob's template immediately. It tests the image, the Pod spec, and your code, but not the schedule, the time zone, or the controller.
Why does my CronJob run at the wrong hour?#
Without .spec.timeZone, the schedule is read in kube-controller-manager's local time zone. Set timeZone to an IANA name such as Europe/Berlin. CRON_TZ or TZ inside the schedule is rejected by validation.
Put this guide to work
Know when the next run is missing
Connect one scheduled job, confirm a real completion, then verify the alert destination. Keep your existing scheduler in charge of running the work.