How to run once at a time → at 03:00
How to Run Once at a Time → at 03:00: Complete Guide to Daily Task Scheduling
Scheduling tasks to run automatically at specific times is a fundamental requirement in system administration, application deployment, and data processing workflows. This comprehensive guide will teach you how to configure various systems and applications to execute tasks once daily at 03:00 (3:00 AM), ensuring your automated processes run during off-peak hours when system resources are typically more available.
Table of Contents
1. [Introduction](#introduction)
2. [Prerequisites and Requirements](#prerequisites-and-requirements)
3. [Understanding Time-Based Task Scheduling](#understanding-time-based-task-scheduling)
4. [Linux/Unix Systems: Using Cron](#linuxunix-systems-using-cron)
5. [Windows Systems: Task Scheduler](#windows-systems-task-scheduler)
6. [Application-Specific Scheduling](#application-specific-scheduling)
7. [Cloud-Based Scheduling Solutions](#cloud-based-scheduling-solutions)
8. [Programming Language Implementations](#programming-language-implementations)
9. [Best Practices and Security Considerations](#best-practices-and-security-considerations)
10. [Troubleshooting Common Issues](#troubleshooting-common-issues)
11. [Monitoring and Logging](#monitoring-and-logging)
12. [Conclusion](#conclusion)
Introduction
Running tasks at 03:00 (3:00 AM) is a common practice in IT operations because this time typically represents a low-activity period for most business applications. Whether you need to perform database backups, system maintenance, data synchronization, or batch processing, scheduling these operations to run once daily at 03:00 ensures minimal impact on user experience and optimal resource utilization.
This guide covers multiple approaches to achieve this scheduling goal across different operating systems, programming languages, and cloud platforms. You'll learn not only how to set up the schedules but also how to ensure reliability, handle failures, and maintain your scheduled tasks effectively.
Prerequisites and Requirements
Before implementing any scheduling solution, ensure you have:
System Requirements
- Administrative or root access to the target system
- Understanding of your operating system's command line interface
- Basic knowledge of the tasks you want to schedule
- Appropriate permissions for the files, directories, or services involved
Technical Knowledge
- Familiarity with command-line operations
- Basic understanding of system processes and services
- Knowledge of the specific application or script you want to schedule
- Understanding of time zones and their impact on scheduling
Planning Considerations
- Clear definition of the task to be executed
- Understanding of task dependencies and prerequisites
- Consideration of system load and resource requirements
- Plan for error handling and failure scenarios
Understanding Time-Based Task Scheduling
Why 03:00?
The 03:00 time slot is strategically chosen for several reasons:
Low System Usage: Most business applications experience minimal user activity during early morning hours, making system resources more available for intensive tasks.
Network Bandwidth: Internet traffic is typically lower at 03:00, providing better bandwidth for data transfers, backups, or synchronization tasks.
Maintenance Windows: Many organizations designate early morning hours as acceptable maintenance windows.
Global Considerations: For businesses operating across multiple time zones, 03:00 local time often represents a compromise that minimizes impact across regions.
Time Zone Considerations
When scheduling tasks for 03:00, always consider:
- System Time Zone: Ensure you understand whether your system uses UTC or local time
- Daylight Saving Time: Account for DST transitions that may affect scheduling
- Multi-Region Deployments: Consider the impact of different time zones in distributed systems
Linux/Unix Systems: Using Cron
Cron is the standard job scheduler for Unix-like operating systems, providing a robust and flexible way to schedule recurring tasks.
Basic Cron Syntax
The cron syntax follows this format:
```
* command-to-execute
│ │ │ │ │
│ │ │ │ └─── Day of week (0-7, where 0 and 7 represent Sunday)
│ │ │ └───── Month (1-12)
│ │ └─────── Day of month (1-31)
│ └───────── Hour (0-23)
└─────────── Minute (0-59)
```
Scheduling a Task for 03:00 Daily
To schedule a task to run once daily at 03:00, use this cron expression:
```bash
0 3 * /path/to/your/script.sh
```
This breaks down as:
- `0`: Execute at minute 0 (beginning of the hour)
- `3`: Execute at hour 3 (03:00 in 24-hour format)
- `*`: Every day of the month
- `*`: Every month
- `*`: Every day of the week
Step-by-Step Implementation
1. Access the Crontab
Open your user's crontab for editing:
```bash
crontab -e
```
For system-wide tasks (requires root access):
```bash
sudo crontab -e
```
2. Add Your Scheduled Task
Add your cron job entry. Here are several examples:
Simple Script Execution:
```bash
0 3 * /home/user/scripts/daily_backup.sh
```
Command with Output Redirection:
```bash
0 3 * /usr/bin/rsync -av /data/ /backup/ >> /var/log/backup.log 2>&1
```
Python Script Execution:
```bash
0 3 * /usr/bin/python3 /home/user/scripts/data_processing.py
```
Database Backup Example:
```bash
0 3 * /usr/bin/mysqldump -u backup_user -p'password' database_name > /backups/db_$(date +\%Y\%m\%d).sql
```
3. Save and Verify
After adding your cron job:
1. Save the crontab file (in nano: Ctrl+X, then Y, then Enter)
2. Verify the cron job was added:
```bash
crontab -l
```
4. Advanced Cron Examples
Running on Weekdays Only:
```bash
0 3 1-5 /path/to/weekday_task.sh
```
Running on the First Day of Each Month:
```bash
0 3 1 /path/to/monthly_task.sh
```
Running with Specific Environment Variables:
```bash
0 3 * PATH=/usr/local/bin:/usr/bin:/bin && /path/to/script.sh
```
System-Wide Cron Configuration
For system-wide scheduled tasks, you can also use:
/etc/crontab File
Edit the system crontab directly:
```bash
sudo nano /etc/crontab
```
Add entries with user specification:
```bash
0 3 * root /path/to/system/script.sh
0 3 * backup /usr/local/bin/backup_script.py
```
/etc/cron.d/ Directory
Create individual cron files:
```bash
sudo nano /etc/cron.d/daily-maintenance
```
Content example:
```bash
Daily maintenance tasks
0 3 * root /usr/local/bin/system_cleanup.sh
0 3 * backup /home/backup/scripts/database_backup.sh
```
Windows Systems: Task Scheduler
Windows Task Scheduler provides a GUI and command-line interface for scheduling tasks on Windows systems.
Using the Task Scheduler GUI
Step 1: Open Task Scheduler
1. Press `Windows + R`, type `taskschd.msc`, and press Enter
2. Or search for "Task Scheduler" in the Start menu
Step 2: Create a Basic Task
1. In the right panel, click "Create Basic Task..."
2. Enter a name and description for your task
3. Click "Next"
Step 3: Configure Trigger
1. Select "Daily" for the trigger
2. Click "Next"
3. Set the start date and time to 03:00:00
4. Set "Recur every: 1 days"
5. Click "Next"
Step 4: Configure Action
1. Select "Start a program"
2. Click "Next"
3. Browse to select your program/script
4. Add arguments if necessary
5. Set the working directory if required
6. Click "Next"
Step 5: Review and Finish
1. Review your settings
2. Check "Open the Properties dialog..." if you need advanced settings
3. Click "Finish"
Using Command Line (schtasks)
For automation and scripting, use the `schtasks` command:
Basic Daily Task at 03:00
```cmd
schtasks /create /tn "DailyBackup" /tr "C:\Scripts\backup.bat" /sc daily /st 03:00:00
```
Advanced Examples
Running with Highest Privileges:
```cmd
schtasks /create /tn "SystemMaintenance" /tr "C:\Scripts\maintenance.ps1" /sc daily /st 03:00:00 /rl highest
```
Running as Specific User:
```cmd
schtasks /create /tn "UserTask" /tr "C:\Scripts\user_script.exe" /sc daily /st 03:00:00 /ru "DOMAIN\username" /rp "password"
```
PowerShell Script Execution:
```cmd
schtasks /create /tn "PowerShellTask" /tr "powershell.exe -File C:\Scripts\script.ps1" /sc daily /st 03:00:00
```
PowerShell Task Scheduling
Use PowerShell for more advanced task creation:
```powershell
Create a new scheduled task action
$Action = New-ScheduledTaskAction -Execute "C:\Scripts\backup.exe" -Argument "-full -compress"
Create a daily trigger at 03:00
$Trigger = New-ScheduledTaskTrigger -Daily -At 3:00AM
Create task settings
$Settings = New-ScheduledTaskSettingsSet -AllowStartIfOnBatteries -DontStopIfGoingOnBatteries
Register the scheduled task
Register-ScheduledTask -Action $Action -Trigger $Trigger -Settings $Settings -TaskName "DailyBackup" -Description "Daily backup at 3 AM"
```
Application-Specific Scheduling
Many applications provide built-in scheduling capabilities that can be configured to run tasks at 03:00.
Database Systems
MySQL Events
Create a MySQL event to run at 03:00 daily:
```sql
CREATE EVENT daily_cleanup
ON SCHEDULE EVERY 1 DAY
STARTS '2024-01-01 03:00:00'
DO
BEGIN
DELETE FROM logs WHERE created_date < DATE_SUB(NOW(), INTERVAL 30 DAY);
OPTIMIZE TABLE user_sessions;
END;
```
PostgreSQL with pg_cron
Install and configure pg_cron extension:
```sql
-- Enable the extension
CREATE EXTENSION pg_cron;
-- Schedule a daily job at 03:00
SELECT cron.schedule('daily-vacuum', '0 3 *', 'VACUUM ANALYZE;');
```
Web Servers and Applications
Apache with mod_cron
Configure Apache to run maintenance tasks:
```apache
In httpd.conf or virtual host configuration
LoadModule cron_module modules/mod_cron.so
SetHandler cron-handler
CronJob "0 3 *" "/path/to/maintenance/script.php"
```
Nginx with System Integration
Nginx typically relies on system cron jobs:
```bash
Add to crontab for nginx maintenance
0 3 * /usr/sbin/nginx -s reload && /usr/local/bin/log_rotation.sh
```
Cloud-Based Scheduling Solutions
Amazon Web Services (AWS)
AWS EventBridge (CloudWatch Events)
Create a scheduled rule using AWS CLI:
```bash
Create the rule
aws events put-rule --name "DailyTask" --schedule-expression "cron(0 3 ? *)"
Add target (Lambda function example)
aws events put-targets --rule "DailyTask" --targets "Id"="1","Arn"="arn:aws:lambda:region:account:function:function-name"
```
AWS Lambda with CloudWatch Events
```python
import json
import boto3
def lambda_handler(event, context):
# Your task logic here
print("Daily task executed at 03:00")
# Example: Start EC2 instances
ec2 = boto3.client('ec2')
response = ec2.start_instances(InstanceIds=['i-1234567890abcdef0'])
return {
'statusCode': 200,
'body': json.dumps('Task completed successfully')
}
```
Google Cloud Platform (GCP)
Cloud Scheduler
Create a scheduled job:
```bash
gcloud scheduler jobs create http daily-task \
--schedule="0 3 *" \
--uri="https://your-cloud-function-url" \
--http-method=POST \
--time-zone="America/New_York"
```
Microsoft Azure
Azure Logic Apps
Create a recurrence trigger in Logic Apps:
```json
{
"recurrence": {
"frequency": "Day",
"interval": 1,
"schedule": {
"hours": [3],
"minutes": [0]
},
"timeZone": "Eastern Standard Time"
}
}
```
Programming Language Implementations
Python Scheduling
Using the `schedule` Library
```python
import schedule
import time
import logging
Configure logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(message)s')
def daily_task():
"""Function to be executed daily at 03:00"""
logging.info("Starting daily task execution")
# Your task logic here
try:
# Example: Database backup
import subprocess
result = subprocess.run(['mysqldump', '-u', 'user', '-p', 'database'],
capture_output=True, text=True)
if result.returncode == 0:
logging.info("Database backup completed successfully")
else:
logging.error(f"Database backup failed: {result.stderr}")
except Exception as e:
logging.error(f"Task execution failed: {str(e)}")
logging.info("Daily task execution completed")
Schedule the task
schedule.every().day.at("03:00").do(daily_task)
Keep the script running
while True:
schedule.run_pending()
time.sleep(60) # Check every minute
```
Using APScheduler (Advanced Python Scheduler)
```python
from apscheduler.schedulers.blocking import BlockingScheduler
from apscheduler.triggers.cron import CronTrigger
import logging
Configure logging
logging.basicConfig(level=logging.INFO)
def daily_maintenance():
"""Daily maintenance task"""
logging.info("Executing daily maintenance at 03:00")
# Your maintenance logic here
# Example tasks:
# - Clean temporary files
# - Update cache
# - Generate reports
logging.info("Daily maintenance completed")
Create scheduler
scheduler = BlockingScheduler()
Add job with cron trigger
scheduler.add_job(
daily_maintenance,
CronTrigger(hour=3, minute=0), # 03:00 daily
id='daily_maintenance',
name='Daily Maintenance Task',
replace_existing=True
)
Start the scheduler
try:
logging.info("Starting scheduler...")
scheduler.start()
except KeyboardInterrupt:
logging.info("Scheduler stopped.")
scheduler.shutdown()
```
Node.js Scheduling
Using node-cron
```javascript
const cron = require('node-cron');
const fs = require('fs');
const path = require('path');
// Function to be executed daily
async function dailyTask() {
console.log(`[${new Date().toISOString()}] Starting daily task`);
try {
// Example: Clean up old log files
const logsDir = './logs';
const files = fs.readdirSync(logsDir);
const thirtyDaysAgo = new Date();
thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30);
files.forEach(file => {
const filePath = path.join(logsDir, file);
const stats = fs.statSync(filePath);
if (stats.mtime < thirtyDaysAgo) {
fs.unlinkSync(filePath);
console.log(`Deleted old log file: ${file}`);
}
});
console.log('Daily task completed successfully');
} catch (error) {
console.error('Daily task failed:', error);
}
}
// Schedule task for 03:00 daily (0 minutes, 3 hours, every day)
cron.schedule('0 3 *', dailyTask, {
scheduled: true,
timezone: "America/New_York"
});
console.log('Daily task scheduled for 03:00');
```
Java Scheduling
Using Spring Boot with @Scheduled
```java
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@Component
public class DailyTaskScheduler {
private static final Logger logger = LoggerFactory.getLogger(DailyTaskScheduler.class);
@Scheduled(cron = "0 0 3 *") // 03:00:00 daily
public void executeDaily Task() {
logger.info("Starting daily task execution at 03:00");
try {
// Your task logic here
performDatabaseMaintenance();
cleanupTempFiles();
generateDailyReports();
logger.info("Daily task completed successfully");
} catch (Exception e) {
logger.error("Daily task execution failed", e);
}
}
private void performDatabaseMaintenance() {
// Database maintenance logic
logger.info("Performing database maintenance");
}
private void cleanupTempFiles() {
// File cleanup logic
logger.info("Cleaning up temporary files");
}
private void generateDailyReports() {
// Report generation logic
logger.info("Generating daily reports");
}
}
```
Best Practices and Security Considerations
Security Best Practices
Principle of Least Privilege
Always run scheduled tasks with the minimum required permissions:
```bash
Create a dedicated user for backup tasks
sudo useradd -r -s /bin/false backup-user
Set up cron job for this user
sudo -u backup-user crontab -e
```
Secure Script Storage
Store scripts in secure locations with appropriate permissions:
```bash
Create secure script directory
sudo mkdir -p /opt/scheduled-tasks
sudo chown root:root /opt/scheduled-tasks
sudo chmod 755 /opt/scheduled-tasks
Set secure permissions on scripts
sudo chmod 750 /opt/scheduled-tasks/backup.sh
sudo chown root:backup-group /opt/scheduled-tasks/backup.sh
```
Environment Variable Security
Avoid storing sensitive information in cron jobs:
```bash
Bad: Passwords in cron job
0 3 * mysqldump -u user -pPASSWORD database > backup.sql
Good: Use configuration files or environment variables
0 3 * /opt/scripts/backup.sh
```
Create a secure configuration file:
```bash
/opt/scripts/backup.sh
#!/bin/bash
source /etc/backup/config # Contains secure credentials
mysqldump -u "$DB_USER" -p"$DB_PASS" "$DB_NAME" > "/backups/backup_$(date +%Y%m%d).sql"
```
Reliability and Error Handling
Implement Proper Logging
```bash
#!/bin/bash
backup.sh with comprehensive logging
LOG_FILE="/var/log/backup.log"
BACKUP_DIR="/backups"
DATE=$(date +%Y%m%d_%H%M%S)
log_message() {
echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" >> "$LOG_FILE"
}
log_message "Starting backup process"
Create backup directory if it doesn't exist
if [ ! -d "$BACKUP_DIR" ]; then
mkdir -p "$BACKUP_DIR"
log_message "Created backup directory: $BACKUP_DIR"
fi
Perform backup with error handling
if mysqldump -u "$DB_USER" -p"$DB_PASS" "$DB_NAME" > "$BACKUP_DIR/backup_$DATE.sql"; then
log_message "Backup completed successfully: backup_$DATE.sql"
# Clean up old backups (keep last 7 days)
find "$BACKUP_DIR" -name "backup_*.sql" -mtime +7 -delete
log_message "Cleaned up old backups"
else
log_message "ERROR: Backup failed"
exit 1
fi
log_message "Backup process completed"
```
Implement Retry Logic
```python
import time
import logging
from functools import wraps
def retry(max_attempts=3, delay=60):
"""Decorator to retry failed operations"""
def decorator(func):
@wraps(func)
def wrapper(args, *kwargs):
for attempt in range(max_attempts):
try:
return func(args, *kwargs)
except Exception as e:
logging.warning(f"Attempt {attempt + 1} failed: {str(e)}")
if attempt < max_attempts - 1:
time.sleep(delay)
else:
logging.error(f"All {max_attempts} attempts failed")
raise
return None
return wrapper
return decorator
@retry(max_attempts=3, delay=120)
def daily_backup():
"""Daily backup with retry logic"""
# Your backup logic here
pass
```
Performance Optimization
Resource Management
Consider system resources when scheduling multiple tasks:
```bash
Stagger tasks to avoid resource conflicts
0 3 * /opt/scripts/database_backup.sh
15 3 * /opt/scripts/file_backup.sh
30 3 * /opt/scripts/log_rotation.sh
45 3 * /opt/scripts/system_cleanup.sh
```
Concurrent Execution Prevention
Prevent multiple instances of the same task:
```bash
#!/bin/bash
Script with lock file mechanism
LOCK_FILE="/var/run/backup.lock"
Check if another instance is running
if [ -f "$LOCK_FILE" ]; then
echo "Another backup process is already running"
exit 1
fi
Create lock file
touch "$LOCK_FILE"
Ensure lock file is removed on exit
trap 'rm -f "$LOCK_FILE"' EXIT
Your task logic here
echo "Performing backup..."
... backup commands ...
echo "Backup completed"
```
Troubleshooting Common Issues
Cron Job Not Running
Check Cron Service Status
```bash
On systemd systems
sudo systemctl status cron
sudo systemctl status crond # On RHEL/CentOS
On SysV init systems
sudo service cron status
```
Verify Cron Job Syntax
```bash
List current cron jobs
crontab -l
Check system logs for cron errors
sudo tail -f /var/log/cron
sudo tail -f /var/log/syslog | grep CRON
```
Common Syntax Issues
```bash
Wrong: Using 24-hour format incorrectly
0 15:00 * /path/to/script.sh # Invalid syntax
Correct: Separate hour and minute
0 15 * /path/to/script.sh
Wrong: Forgetting to specify minute
3 * /path/to/script.sh # Will run every minute during hour 3
Correct: Specify minute as 0
0 3 * /path/to/script.sh
```
Environment Issues
PATH Problems
Cron jobs run with a minimal environment. Specify full paths:
```bash
Problem: Command not found
0 3 * python script.py
Solution: Use full paths
0 3 * /usr/bin/python3 /home/user/scripts/script.py
Or set PATH in crontab
PATH=/usr/local/bin:/usr/bin:/bin
0 3 * python3 /home/user/scripts/script.py
```
Missing Environment Variables
```bash
Load environment in script
#!/bin/bash
source /etc/environment
source ~/.bashrc
Your script logic here
```
Permission Issues
File Permissions
```bash
Make script executable
chmod +x /path/to/script.sh
Check file ownership
ls -la /path/to/script.sh
Fix ownership if needed
sudo chown user:group /path/to/script.sh
```
Directory Access
```bash
Ensure cron user can access directories
Check parent directory permissions
ls -la /path/to/
ls -la /path/to/scripts/
```
Time Zone Issues
Verify System Time Zone
```bash
Check current time zone
timedatectl status
date
Set time zone if needed
sudo timedatectl set-timezone America/New_York
```
Handle Daylight Saving Time
Consider using UTC for critical tasks:
```bash
Run at 03:00 UTC instead of local time
0 3 * TZ=UTC /path/to/script.sh
```
Windows Task Scheduler Issues
Task Not Running
1. Check Task Scheduler Library for error messages
2. Verify the task trigger configuration
3. Ensure the user account has necessary permissions
4. Check if the system was powered on at scheduled time
Common Windows Issues
```cmd
REM Check task status
schtasks /query /tn "TaskName" /v
REM Run task manually for testing
schtasks /run /tn "TaskName"
REM Check task history
REM Enable task history in Task Scheduler if disabled
```
Monitoring and Logging
Implementing Comprehensive Monitoring
Log Rotation Setup
```bash
Create logrotate configuration
sudo nano /etc/logrotate.d/scheduled-tasks
Content:
/var/log/scheduled-tasks/*.log {
daily
rotate 30
compress
delaycompress
missingok
notifempty
create 644 root root
}
```
Email Notifications
```bash
Add email notification to cron job
MAILTO=admin@example.com
0 3 * /opt/scripts/backup.sh
```
Advanced Monitoring Script
```bash
#!/bin/bash
monitoring.sh - Comprehensive task monitoring
TASK_NAME="DailyBackup"
LOG_FILE="/var/log/scheduled-tasks/$TASK_NAME.log"
ALERT_EMAIL="admin@example.com"
MAX_RUNTIME=3600 # 1 hour in seconds
log_with_timestamp() {
echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" | tee -a "$LOG_FILE"
}
send_alert() {
local subject="$1"
local message="$2"
echo "$message" | mail -s "$subject" "$ALERT_EMAIL"
}
Record start time
START_TIME=$(date +%s)
log_with_timestamp "Starting $TASK_NAME"
Execute the actual task
if /opt/scripts/actual_task.sh; then
TASK_STATUS="SUCCESS"
log_with_timestamp "$TASK_NAME completed successfully"
else
TASK_STATUS="FAILED"
log_with_timestamp "ERROR: $TASK_NAME failed"
send_alert "$TASK_NAME Failed" "The scheduled task $TASK_NAME failed at $(date)"
fi
Calculate runtime
END_TIME=$(date +%s)
RUNTIME=$((END_TIME - START_TIME))
log_with_timestamp "Task runtime: ${RUNTIME} seconds"
Check for excessive runtime
if [ $RUNTIME -gt $MAX_RUNTIME ]; then
send_alert "$TASK_NAME Runtime Warning" "Task $TASK_NAME took ${RUNTIME} seconds (threshold: ${MAX_RUNTIME})"
fi
Log system resources
log_with_timestamp "System load: $(uptime)"
log_with_timestamp "Disk usage: $(df -h / | tail -1)"
log_with_timestamp "Memory usage: $(free -h | grep Mem:)"
```
Health Check Implementation
```python
#!/usr/bin/env python3
health_check.py - Monitor scheduled task health
import os
import sys
import time
import smtplib
from email.mime.text import MIMEText
from datetime import datetime, timedelta
class TaskHealthMonitor:
def __init__(self, task_name, expected_runtime_minutes=60):
self.task_name = task_name
self.log_file = f"/var/log/scheduled-tasks/{task_name}.log"
self.expected_runtime = expected_runtime_minutes
self.alert_email = "admin@example.com"
def check_last_execution(self):
"""Check if task ran in the last 25 hours"""
try:
with open(self.log_file, 'r') as f:
lines = f.readlines()
# Look for completion messages in last 100 lines
for line in reversed(lines[-100:]):
if "completed successfully" in line:
# Extract timestamp
timestamp_str = line.split(']')[0][1:]
timestamp = datetime.strptime(timestamp_str, '%Y-%m-%d %H:%M:%S')
# Check if within last 25 hours
if datetime.now() - timestamp < timedelta(hours=25):
return True, timestamp
return False, None
except FileNotFoundError:
return False, None
def send_alert(self, subject, message):
"""Send email alert"""
try:
msg = MIMEText(message)
msg['Subject'] = subject
msg['From'] = 'scheduler@example.com'
msg['To'] = self.alert_email
smtp_server = smtplib.SMTP('localhost')
smtp_server.send_message(msg)
smtp_server.quit()
except Exception as e:
print(f"Failed to send alert: {e}")
def run_health_check(self):
"""Run complete health check"""
success, last_run = self.check_last_execution()
if not success:
self.send_alert(
f"{self.task_name} Health Check Alert",
f"Task {self.task_name} has not completed successfully in the last 25 hours."
)
return False
print(f"Health check passed. Last successful run: {last_run}")
return True
if __name__ == "__main__":
if len(sys.argv) != 2:
print("Usage: health_check.py ")
sys.exit(1)
monitor = TaskHealthMonitor(sys.argv[1])
monitor.run_health_check()
```
Conclusion
Successfully implementing tasks that run once daily at 03:00 requires careful consideration of multiple factors including system architecture, security requirements, error handling, and monitoring capabilities. This comprehensive guide has covered the essential techniques and best practices across different platforms and technologies