Run Weekly Backups on Mondays at 2 AM | CronBase

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

// Schedule task to run at 2:00 AM every Monday
cron.schedule('0 2 * * 1', () => {
    console.log(`[${new Date().toISOString()}] Initiating weekly cleanup...`);
    
    exec('/usr/local/bin/cleanup-script.sh', (error, stdout, stderr) => {
        if (error) {
            console.error(`Execution error: ${error.message}`);
            return;
        }
        if (stderr) {
            console.warn(`Execution warning: ${stderr}`);
        }
        console.log(`Execution success: ${stdout}`);
    });
}, {
    scheduled: true,
    timezone: "UTC"
});

#!/usr/bin/env bash
set -euo pipefail

# Define lock file to prevent concurrent executions
LOCKFILE="/var/lock/weekly-maintenance.lock"

# Execute weekly task with flock to ensure exclusive execution
exec 9>"$LOCKFILE"
if flock -n 9; then
    echo "[$(date -u)] Starting weekly maintenance task..."
    # Insert production commands here
    # Example: /usr/local/bin/backup-db.sh
    echo "[$(date -u)] Task completed successfully."
else
    echo "[$(date -u)] Error: Task is already running!"
    exit 1
fi

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

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger('weekly_scheduler')

def run_weekly_job():
    logger.info(f"Starting weekly job at {datetime.utcnow()} UTC")
    try:
        # Place production workload here
        pass
    except Exception as e:
        logger.error(f"Job failed: {str(e)}")

scheduler = BlockingScheduler(timezone='UTC')
# '1' represents Monday in APScheduler cron format
scheduler.add_job(run_weekly_job, 'cron', day_of_week='mon', hour=2, minute=0)

try:
    logger.info("Starting scheduler...")
    scheduler.start()
except (KeyboardInterrupt, SystemExit):
    logger.info("Scheduler stopped.")

package main

import (
	"log"
	"os"
	"os/signal"
	"syscall"
	"time"

	"github.com/robfig/cron/v3"
)

func main() {
	// Use UTC timezone to avoid DST issues
	nyc, err := time.LoadLocation("UTC")
	if err != nil {
		log.Fatalf("Failed to load timezone: %v", err)
	}

	c := cron.New(cron.WithLocation(nyc))

	_, err = c.AddFunc("0 2 * * 1", func() {
		log.Println("Weekly Monday job started...")
		// Implement your logic here
	})
	if err != nil {
		log.Fatalf("Error scheduling job: %v", err)
	}

	c.Start()
	log.Println("Cron engine started. Waiting for Monday 2:00 AM UTC...")

	// Keep application running until interrupted
	sig := make(chan os.Signal, 1)
	signal.Notify(sig, syscall.SIGINT, syscall.SIGTERM)
	<-sig
	c.Stop()
}

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import java.time.Instant;
import java.util.logging.Logger;

@Component
public class WeeklyMaintenanceScheduler {
    private static final Logger LOGGER = Logger.getLogger(WeeklyMaintenanceScheduler.class.getName());

    // Standard Spring Cron format: second, minute, hour, day of month, month, day of week
    @Scheduled(cron = "0 0 2 * * MON", zone = "UTC")
    public void executeWeeklyTask() {
        LOGGER.info("Weekly Monday maintenance started at " + Instant.now());
        try {
            // Perform database optimization or log rotation
        } catch (Exception e) {
            LOGGER.severe("Weekly maintenance failed: " + e.getMessage());
        }
    }
}

apiVersion: batch/v1
kind: CronJob
metadata:
  name: weekly-database-cleanup
  namespace: production
spec:
  schedule: "0 2 * * 1"
  concurrencyPolicy: Forbid
  successfulJobsHistoryLimit: 3
  failedJobsHistoryLimit: 5
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: database-cleaner
            image: postgres:15-alpine
            command:
            - /bin/sh
            - -c
            - "vacuumdb -U postgres -d production_db -z -v"
            env:
            - name: PGPASSWORD
              valueFrom:
                secretKeyRef:
                  name: db-secrets
                  key: password
          restartPolicy: OnFailure