How to Use Cron Jobs in Linux

Edited 10 hours ago by ExtremeHow Editorial Team

AutomationSchedulingCommand LineTask ManagementScriptsSystem MaintenanceDate/Time ManagementUtilitiesScriptingSysAdmin

Cron jobs are a very powerful and flexible system for scheduling tasks in Linux. They let you automate processes, routines or scripts on your server. Imagine being able to automate your backups, check system status, clear temporary files or send recurring emails without having to remember to do these tasks manually. Cron jobs run in the background at scheduled times. Using cron can not only save you effort but also save precious hours of your work and increase overall system efficiency.

Getting started with cron jobs

The cron daemon is a background process that manages cron jobs in Linux. For cron jobs to work, the cron daemon must be running on your system. Most Linux distributions come with cron pre-installed. However, if it is not installed, you can install it using your package manager.

Here's how to do it on different distributions:

Debian/Ubuntu based systems:
sudo apt-get update sudo apt-get install cron
Red Hat/CentOS based systems:
sudo yum update sudo yum install cronie

Once installed, you can start the cron service using the following:

sudo systemctl start cron

Make sure it starts on boot by enabling it:

sudo systemctl enable cron

Understanding the cron table (crontab)

Cron jobs are defined in a file called a crontab. Each user can have their own crontab, and there is also a system-wide crontab file. The crontab file defines the schedule and command for each cron job. You can edit a user crontab using the `crontab -e` command. This opens the crontab file in the default system editor.

The crontab file contains lines, each of which represents a scheduled task, defined in a specific syntax. A typical cron job entry looks like this:

* * * * * /path/to/command

Each field is separated by a space and represents a different time unit:

• Minutes (0-59): The exact minute the job should run.
• Hour (0-23): The hour of the day.
• Day of Month (1-31): The day of the month when the job should run.
• Month (1-12): Month of the year.
• Day of week (0-7): The day of the week (both 0 and 7 refer to Sunday).

The command itself follows these time specifications and defines which action will be executed.

General scheduling example

Let's look at some examples to better understand how a cron job schedule works.

• Daily at 2 AM: Execute the backup script daily at 2 AM.

  0 2 * * * /path/to/backup.sh
  

• Hourly: Run a log rotation script every hour.

  0 * * * * /usr/local/bin/logrotate
  

• Every Sunday at midnight: Run the maintenance script once each week.

  0 0 * * 0 /usr/local/bin/maintenance
  

• First day of every month at 12pm: Prepare the report.

  0 12 1 * * /usr/local/bin/generate-report
  

Cron also supports using operators such as comma, hyphen, and slash to define multiple values or intervals. Here's how:

• Comma (,): Allows you to list multiple values. Run the script at 1 o'clock and 3 o'clock.

  0 1,3 * * * /path/to/script
  

• Dash (-): Specifies a range of values. Execute a task every minute between 5 AM and 5:10 AM.

  */1 5 1-10 * * /path/to/task
  

• Slash (/): Specifies the interval. Run every 30 minutes.

  */30 * * * * /path/to/half-hourly-task
  

Environment variables

The cron job runs in its own limited environment, and sometimes, it may not have the same settings as your user shell. Often, it is necessary to set environment variables in the crontab file for the script to execute correctly. For example, it is common to set the PATH variable:

PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin * * * * * /path/to/myjob

Output redirection and logging

By default, cron sends mail to the user who runs the cron job, containing any output produced by the job. If you don't want to receive output by mail, or you want to log it, you can redirect the output to a file.

Here's how you can redirect standard output and error:

* * * * * /path/to/script > /path/to/logfile 2>&1

This example sends both the output and any error messages to a log file.

Using the crontab command

The `crontab` command is the primary way to set up cron jobs. Here are the most commonly used options:

• crontab -e: Edit your user's crontab.
• crontab -l: List your user's cron jobs.
• crontab -r: Delete your user's crontab.
• crontab -u username -e: Edit another user's crontab if you have permission.

Advanced cron job management

Aside from the basic operations, there are also advanced usage patterns that you can use to further leverage the power of cron jobs.

Linking jobs with dependencies

Sometimes, you want some tasks to run only if another one completes successfully. In such cases, scripting comes to the rescue. You can create a master script that first calls one script and then the other, checking the exit conditions or expected results.

#!/bin/bash if /path/to/first-script; then /path/to/second-script fi

Put this master script in your crontab, and you've effectively combined the two tasks.

Temporary cron files

Sometimes, you may find it convenient to use a temporary crontab file, especially in scripting scenarios. You can create a crontab file and use it with the `crontab` command as follows:

crontab mycronfile

This command sets up the user's cron jobs based on the contents of mycronfile.

Editing system-wide cron jobs

In addition to the personal crontab, there is a system crontab file that schedules jobs for all users. It is located at /etc/crontab. Here, jobs have an additional field before the command, which specifies the user under which the script will run. General system maintenance scripts can be found here.

/etc/crontab * * * * * user /path/to/command

Additionally, scripts in directories such as /etc/cron.hourly, /etc/cron.daily, /etc/cron.weekly, and /etc/cron.monthly are executed at their respective times, and this is managed by the system configuration.

Handling special cron keywords

Crontab also supports special strings instead of five fields:

• @reboot: Run once at startup.
• @yearly or @annually: Once a year, 0 0 1 1 *.
• @monthly: Once a month, 0 0 1 * *.
• @weekly: once a week, 0 0 * * 0.
• @daily: once a day, 0 0 * * *.
• @hourly: once an hour, 0 * * * *.

These keywords make it easier to determine common programs.

Security considerations

Security is an important consideration when dealing with cron jobs. Users with access to the cron facility can create their own jobs, which can interact with the system. /etc/cron.allow and /etc/cron.deny files can manage which users have the privilege to use cron.

By default, if /etc/cron.allow exists, it must contain the name of the user to allow them access to cron. Otherwise, if /etc/cron.deny exists, it must not contain the name of the user to allow access. If these files do not exist, usually, only root can schedule cron jobs.

Testing and troubleshooting cron jobs

Cron jobs can cause errors if the command syntax is incorrect or if environmental conditions are not met. Here are some ways to test and troubleshoot cron jobs.

Tests

Test your command manually in the terminal to make sure it works as expected, as cron will not provide an interactive prompt.

Temporarily set the cron job to run every minute to make sure it triggers correctly.

* * * * * /path/to/command

Troubleshooting

You can check the log of the cron daemon for any problems. This log file is usually located here:

/var/log/cron /var/log/syslog (depending on the distribution)

This log can help determine if the cron job was executed or if it encountered an error.

As mentioned earlier, redirecting the output to a file can help capture error messages for investigation.

Conclusion

Cron is a fundamental tool on Linux systems, providing automated task scheduling with reliability and flexibility. By understanding the syntax, environment, and configuration of cron jobs, you can efficiently manage routine tasks, thereby optimizing your work processes. Whether you are a system administrator or a developer, mastering cron jobs can significantly increase your productivity.

Hopefully, this detailed guide will help you use cron jobs effectively. Enjoy scheduling!

  Share This Article

If you find anything wrong with the article content, you can request an update