Schedule Daily Maintenance at 6:00 AM | CronBase

#!/usr/bin/env bash
# Production deployment script for standard cron
set -euo pipefail

CRON_JOB="0 6 * * * /usr/local/bin/daily-cleanup.sh >> /var/log/daily-cleanup.log 2>&1"

# Ensure the script exists and is executable
if [ ! -x /usr/local/bin/daily-cleanup.sh ]; then
    echo "Error: /usr/local/bin/daily-cleanup.sh not found or not executable" >&2
    exit 1
fi

# Install the cron job safely without overwriting existing jobs
(crontab -l 2>/dev/null | grep -Fv "/usr/local/bin/daily-cleanup.sh"; echo "$CRON_JOB") | crontab -
echo "Cron job installed successfully."

const cron = require('node-cron');
const { exec } = require('child_process');

// Schedule task to run daily at 6:00 AM
cron.schedule('0 6 * * *', () => {
    console.log(`[${new Date().toISOString()}] Starting daily maintenance task...`);
    
    exec('/usr/local/bin/daily-task.sh', (error, stdout, stderr) => {
        if (error) {
            console.error(`[ERROR] Task failed: ${error.message}`);
            return;
        }
        if (stderr) {
            console.warn(`[WARN] Task output warning: ${stderr}`);
        }
        console.log(`[SUCCESS] Task completed: ${stdout.trim()}`);
    });
}, {
    scheduled: true,
    timezone: "UTC"
});

import logging
from apscheduler.schedulers.blocking import BlockingScheduler
import sys

logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

def execute_daily_job():
    try:
        logger.info("Starting the scheduled daily 6:00 AM job.")
        # Perform the actual business logic here
        logger.info("Daily job completed successfully.")
    except Exception as e:
        logger.error(f"Daily job failed with error: {str(e)}", exc_info=True)
        sys.exit(1)

if __name__ == '__main__':
    scheduler = BlockingScheduler()
    # Trigger set to 6:00 AM daily
    scheduler.add_job(execute_daily_job, 'cron', hour=6, minute=0, timezone='UTC')
    logger.info("Scheduler started. Task configured for 6:00 AM daily.")
    try:
        scheduler.start()
    except (KeyboardInterrupt, SystemExit):
        logger.info("Scheduler stopped cleanly.")

package main

import (
	"log"
	"os"
	"os/signal"
	"syscall"
	"github.com/robfig/cron/v3"
)

func main() {
	logger := log.New(os.Stdout, "CRON: ", log.LstdFlags|log.Lshortfile)
	
	// Use UTC timezone for predictable production execution
	c := cron.New(cron.WithLocation(cron.WithSeconds().Location()))
	
	_, err := c.AddFunc("0 6 * * *", func() {
		logger.Println("Executing daily 6:00 AM scheduled task...")
		if err := runMaintenanceTask(); err != nil {
			logger.Printf("ERROR: Task execution failed: %v", err)
		} else {
			logger.Println("SUCCESS: Task completed successfully")
		}
	})
	if err != nil {
		logger.Fatalf("Failed to schedule job: %v", err)
	}

	c.Start()
	logger.Println("Scheduler running. Waiting for 6:00 AM trigger...")

	// Handle graceful shutdown
	sigChan := make(chan os.Signal, 1)
	signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
	<-sigChan
	
	logger.Println("Shutting down scheduler...")
	c.Stop()
}

func runMaintenanceTask() error {
	// Business logic goes here
	return nil
}

package com.example.cron;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@Component
public class DailyTaskScheduler {

    private static final Logger logger = LoggerFactory.getLogger(DailyTaskScheduler.class);

    // Runs daily at 6:00 AM (configured using standard cron syntax)
    @Scheduled(cron = "0 6 * * *", zone = "UTC")
    public void executeDailyTask() {
        logger.info("Initiating scheduled daily maintenance task at 6:00 AM UTC");
        try {
            performCleanup();
            logger.info("Daily maintenance task completed successfully");
        } catch (Exception e) {
            logger.error("Critical error during daily task execution", e);
            // Trigger external alerting system here
        }
    }

    private void performCleanup() {
        // Actual implementation logic
    }
}

apiVersion: batch/v1
kind: CronJob
metadata:
  name: daily-maintenance-job
  namespace: production
spec:
  schedule: "0 6 * * *"
  concurrencyPolicy: Forbid
  successfulJobsHistoryLimit: 3
  failedJobsHistoryLimit: 5
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: worker
            image: custom-registry.io/ops/maintenance-worker:v1.2.0
            resources:
              limits:
                cpu: "500m"
                memory: "512Mi"
              requests:
                cpu: "200m"
                memory: "256Mi"
            env:
            - name: ENVIRONMENT
              value: "production"
          restartPolicy: OnFailure