How to Run Cron Jobs Every 5, 10, 15, or 30 Minutes in Linux

In Linux systems, Cron is a powerful tool for automating repetitive tasks. By configuring Cron appropriately, users can easily schedule tasks to run every 5, 10, 15, or 30 minutes. This article will delve into how to use Cron to implement scheduled tasks at these intervals, covering everything from basic concepts to advanced configurations, aiming to provide readers with comprehensive and practical guidance.

1. Introduction to Cron and Its Working Principle

1. What is Cron?

Cron is a time-based job scheduler widely used in Linux and Unix-like systems. It allows users to automatically execute scripts, commands, or programs at specified time intervals or points. The core components of Cron include the crond daemon and the crontab configuration file.

crond: The daemon for Cron, running in the background, responsible for reading and executing tasks defined in the crontab file.
crontab: The task configuration file for users or the system, storing the scheduling rules and commands for scheduled tasks.

2. Cron Expression Format

Cron uses a specific time expression to define when tasks should run. A standard Cron expression consists of 6 fields, formatted as follows:

* * * * *  command_to_execute
- - - - -
| | | | |
| | | | +---- Day of the week (0-6, 0 is Sunday)
| | | +------ Month (1-12)
| | +-------- Day of the month (1-31)
| +---------- Hour (0-23)
+------------ Minute (0-59)

Each field can be defined in the following ways:

Specific value: e.g., 5 means the 5th minute.
Range: e.g., 1-5 means from 1 to 5 minutes.
Interval: e.g., */5 means every 5 minutes.
List: e.g., 5,10,15 means the 5th, 10th, and 15th minutes.

3. Cron Expressions for Running Every 5, 10, 15, and 30 Minutes

To run tasks at fixed intervals, we mainly use the interval symbol */n, where n is the time interval (in minutes). Here are the corresponding Cron expressions:

Every 5 minutes: */5 * * * *
Every 10 minutes: */10 * * * *
Every 15 minutes: */15 * * * *
Every 30 minutes: */30 * * * *

These expressions indicate that tasks will be triggered at specified intervals in the minute field of each hour. For example, */5 * * * *<code> will run at 0, 5, 10, ..., 55 minutes.

2. Steps to Configure Cron Tasks

1. Ensure the Cron Service is Running

In most Linux distributions (like Ubuntu, CentOS), Cron is installed and running by default. You can check the status of the crond service with the following command:

sudo systemctl status cron

If the service is not running, you can start it and set it to start on boot:

sudo systemctl start cron
sudo systemctl enable cron

For SysVinit-based systems (like older CentOS 6), use:

sudo service crond status
sudo service crond start
sudo chkconfig crond on

2. Edit the Crontab File

Users can edit their scheduled tasks using the crontab command. Here are the specific steps:

(1) Open the Crontab Editor

Run the following command to open the user’s crontab file:

crontab -e

On the first run, the system may prompt you to select an editor (like nano or vim). After selecting your preferred editor, you will enter the crontab editing interface.

(2) Add Scheduled Tasks

In the crontab file, add the following example tasks to run every 5, 10, 15, or 30 minutes:

# Run script every 5 minutes
*/5 * * * * /path/to/script.sh

# Run command every 10 minutes
*/10 * * * * /usr/bin/python3 /path/to/script.py

# Run backup command every 15 minutes
*/15 * * * * /bin/bash /path/to/backup.sh

# Run cleanup task every 30 minutes
*/30 * * * * rm -f /tmp/*.log

Notes:

Ensure the script path (e.g., /path/to/script.sh) is correct and that the script has executable permissions (use chmod +x script.sh).
Commands must use absolute paths (e.g., /usr/bin/python3), as Cron has limited environment variables.
Each line must end with a newline; otherwise, the last line may not be executed.

(3) Save and Verify

After saving the file, Cron will automatically load the new configuration. You can view the user’s crontab with the following command:

crontab -l

3. Example Script

Here is a simple Bash script example for testing Cron scheduled tasks:

#!/bin/bash
# File: /path/to/log_time.sh
echo "Task executed at $(date)" >> /var/log/cron_task.log

Create and grant executable permissions:

touch /path/to/log_time.sh
chmod +x /path/to/log_time.sh

Add the following content to crontab to log the time every 5 minutes:

*/5 * * * * /path/to/log_time.sh

After running, check if /var/log/cron_task.log has recorded the timestamps.

3. Advanced Configurations and Considerations

1. Setting Environment Variables

Cron runs with environment variables that differ from the user’s login shell environment, which may lack PATH or other variables, causing commands to be unrecognized. You can set environment variables in the following ways:

Add at the top of the crontab file:

PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin

Or specify environment variables for specific tasks:

*/5 * * * * PATH=/custom/path:/usr/bin /path/to/script.sh

2. Logging and Error Troubleshooting

Cron does not send task output to the terminal by default; you can redirect output to a file for debugging:

*/5 * * * * /path/to/script.sh >> /var/log/cron_output.log 2>&1

>>: Appends standard output to the file.
2>&1: Redirects standard error to standard output.

If tasks do not execute, check the following:

Cron Logs: On Ubuntu, check /var/log/syslog or /var/log/cron; on CentOS, check /var/log/cron.
Permission Issues: Ensure scripts and target files have appropriate permissions.
Path Issues: Use absolute paths to avoid relative paths.

3. System-Level Crontab

In addition to user-level crontab, system-level tasks can be implemented by editing /etc/crontab or the /etc/cron.* directories. For example:

# Edit /etc/crontab
sudo nano /etc/crontab

Add the following content (note that system-level crontab has an additional user field):

*/5 * * * * root /path/to/script.sh

Additionally, the /etc/cron.d/ directory can be used to store custom task files, formatted the same as /etc/crontab.

4. Limiting the Runtime of Cron Tasks

If tasks may take a long time, you can use the timeout command to limit runtime:

*/5 * * * * /usr/bin/timeout 60 /path/to/script.sh

The above command limits the script’s runtime to 60 seconds.

5. Avoiding Task Overlap

If a task’s runtime may exceed the interval (e.g., running every 5 minutes but taking 6 minutes), it may lead to task overlap. You can use the flock command to lock:

*/5 * * * * /usr/bin/flock -n /tmp/script.lock /path/to/script.sh

-n means that if the lock is occupied, it will exit immediately to avoid running again.

4. Practical Application Scenarios

1. Check System Status Every 5 Minutes

The following task records system load every 5 minutes:

*/5 * * * * /bin/bash -c "uptime >> /var/log/system_load.log"

2. Synchronize Time Every 10 Minutes

Ensure the system time is accurate:

*/10 * * * * /usr/sbin/ntpdate pool.ntp.org

3. Backup Database Every 15 Minutes

Use mysqldump to back up a MySQL database:

*/15 * * * * /usr/bin/mysqldump -u root -pPASSWORD dbname > /backup/db_$(date +\%F_\%H\%M).sql

4. Clean Temporary Files Every 30 Minutes

Clean expired files in the /tmp directory:

*/30 * * * * /usr/bin/find /tmp -type f -mtime +1 -delete