Job & Cron Job

Job

• Pods normally are created to run forever. Pods are managed by jobs
• To create a Pod that runs up to completion, use Jobs instead
• Jobs are useful for one-shot tasks, like backup, calculation, batch processing and more
• Use spec.ttlSecondsAfterFinished to clean up completed Jobs automatically
• Job doesn't get deleted by itself we have to delete it.

Understanding Job Types

3 different Job types can be started, which is specified by the completions and parallelism parameters:

• Non-parallel Jobs: one Pod is started, unless the Pod fails
  • completions=1
  • parallelism=1
• Parallel Jobs with a fixed completion count: the Job is complete after successfully running as many times as specified in jobs.spec.completions
  • completions=n
  • parallelism=m
• Parallel Jobs with a work queue: multiple Jobs are started, when one completes successfully, the Job is complete
  • completions=1
  • parallelism=n

Parallelism

A way of running multiple pods in order to complete a task. Here we define how many pods we require addiitonally to finish the job.

For example -

apiVersion: batch/v1
kind: Job
metadata:
  name: onejob
spec:
  parallelism: 3
  ttlSecondsAfterFinished: 10
  template:
    metadata:
      name: testjob
    spec:
      containers:
      - command:
        - sleep
        - "5"
        image: busybox
        name: onejob
      restartPolicy: Never

This will create 3 pods at once to complete our task and wait for addiitonal 10 second to delete the job

Usually the retartPolicy is set to true for pods by default but in case of jobs it's false

Demo: Managing Jobs

If you want to view the realtime working at background use watch <kubectl command>

apiVersion: batch/v1
kind: Job
metadata:
  creationTimestamp: null
  name: onejob
spec:
  completions: 3
  ttlSecondsAfterFinished: 60
  template:
    metadata:
      creationTimestamp: null
    spec:
      containers:
      - command:
        - sleep
        - "5"
        image: busybox
        name: onejob
        resources: {}

This will create the three job and after completion it will wait for 60s before deleting the job itself usng ttlSecondsAfterFinished.

We can use the following command as welll to create a job kubectl create job onejob --image=busybox -- date

Craete the job and monitor the job

kubectl create -f k8s_example_16.yaml
kubectl get jobs

controlplane $ kubectl create -f k8s_example_16.yaml
job.batch/onejob created
NAME               STATUS     COMPLETIONS   DURATION   AGE
job.batch/onejob   Complete   3/3           27s        44s

NAME               READY   STATUS      RESTARTS   AGE
pod/onejob-6c44w   0/1     Completed   0          44s
pod/onejob-6nvbg   0/1     Completed   0          26s
pod/onejob-wj7wt   0/1     Completed   0          35s

As you see the job has been cpmpleted in 27 seconds and now it will wait for addiitonal 60s before it get deleted.

controlplane $ kubectl get jobs,pods
No resources found in default namespace.

• If we were not using ttlSecondsAfterFinished the job is meant to control pods and run specific number of times.
• In that case the restartPolicy value will be set to false by default.

controlplane $ kubectl get jobs -o yaml | grep restartPolicy
        restartPolicy: Never

Cron Job

• Jobs are used to run a task a specific number of times
• CronJobs are used for tasks that need to run on a regular basis
• When running a CronJob, a Job will be scheduled

Demo: Managing Cron Job

Let's create a cronjob

kubectl create cronjob -h | less
kubectl create cronjob runme --image=busybox --schedule="*/1 * * * *" -- echo greetings from your cluster

Here, */1 means every minute, the next * represent hours, then the next one represent day of month, then month and then week.

kubectl get cronjobs,jobs,pods

controlplane $ kubectl get cronjobs,jobs,pods
NAME                  SCHEDULE      TIMEZONE   SUSPEND   ACTIVE   LAST SCHEDULE   AGE
cronjob.batch/runme   */1 * * * *   <none>     False     0        <none>          17s

Here the job is not yet started though it's initiated because cronjobs is scheduled to run every minute so we have to wait until a min pass.

controlplane $ kubectl get cronjobs,jobs,pods
NAME                  SCHEDULE      TIMEZONE   SUSPEND   ACTIVE   LAST SCHEDULE   AGE
cronjob.batch/runme   */1 * * * *   <none>     False     0        37s             71s

NAME                       STATUS     COMPLETIONS   DURATION   AGE
job.batch/runme-28825612   Complete   1/1           3s         37s

NAME                       READY   STATUS      RESTARTS   AGE
pod/runme-28825612-6ffk9   0/1     Completed   0          37s

As you notice it say the LAST SCHEDULE was 37s, that is the next job will be created after 23 seconds.

So, likewise it iwll keep on creating new jobs and it will be a busy terminal if we don't cleanup so it's advised to do that automatically. for now we will delete the job manually by deleting cronjob..

kubectl logs runme-28825612-6ffk9

controlplane $ kubectl logs runme-28825612-6ffk9
greetings from your cluster

kubectl delete cronjob runme

cronjob.batch "runme" deleted