Run Daily Backups and Syncs at 10 PM | CronBase

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

// Schedule task to run daily at 22:00 (10:00 PM)
cron.schedule('0 22 * * *', () => {
  console.log(`[${new Date().toISOString()}] Starting nightly database backup...`);
  
  exec('/usr/local/bin/backup-db.sh', (error, stdout, stderr) => {
    if (error) {
      console.error(`[ERROR] Backup failed: ${error.message}`);
      return;
    }
    if (stderr) {
      console.warn(`[WARN] Backup stderr: ${stderr}`);
    }
    console.log(`[SUCCESS] Backup completed. Output: ${stdout}`);
  });
}, {
  scheduled: true,
  timezone: "Etc/UTC"
});

# Edit your crontab using: crontab -e
# Standard cron entry to run a backup script at 10:00 PM daily
# Uses flock to prevent overlapping executions and redirects output to a log file
0 22 * * * /usr/bin/flock -n /var/run/daily_backup.lck /usr/local/bin/daily_backup.sh >> /var/log/cron/daily_backup.log 2>&1

import logging
from apscheduler.schedulers.blocking import BlockingScheduler

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

def run_nightly_sync():
    logging.info("Starting nightly synchronization task...")
    try:
        # Core business logic or subprocess call goes here
        pass
        logging.info("Nightly synchronization task completed successfully.")
    except Exception as e:
        logging.error(f"Task failed with error: {e}", exc_info=True)

if __name__ == "__main__":
    scheduler = BlockingScheduler()
    # Trigger daily at 22:00 (10:00 PM)
    scheduler.add_job(run_nightly_sync, 'cron', hour=22, minute=0, timezone='UTC')
    logging.info("Scheduler started. Waiting for 22:00 UTC...")
    try:
        scheduler.start()
    except (KeyboardInterrupt, SystemExit):
        logging.info("Scheduler stopped cleanly.")

package main

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

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

func main() {
	// Initialize cron with UTC location to ensure consistent execution
	c := cron.New(cron.WithLocation(time.UTC))

	_, err := c.AddFunc("0 22 * * *", func() {
		log.Println("Starting scheduled daily cleanup job at 22:00 UTC...")
		ctx, cancel := context.WithTimeout(context.Background(), 30*time.Minute)
		defer cancel()

		if err := executeCleanup(ctx); err != nil {
			log.Printf("Error during cleanup: %v", err)
		} else {
			log.Println("Daily cleanup job finished successfully.")
		}
	})

	if err != nil {
		log.Fatalf("Failed to schedule cron job: %v", err)
	}

	c.Start()
	log.Println("Cron scheduler initiated. Waiting for daily 22:00 execution...")

	// Graceful shutdown handling
	sigChan := make(chan os.Signal, 1)
	signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
	<-sigChan

	log.Println("Stopping cron scheduler...")
	c.Stop()
}

func executeCleanup(ctx context.Context) error {
	// Simulate background execution work
	time.Sleep(5 * time.Second)
	return nil
}

package com.example.scheduler;

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

@Component
public class NightlyTaskScheduler {

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

    // Spring cron format uses 6 fields: second, minute, hour, day, month, day-of-week
    // Runs at 22:00:00 (10 PM) every day in UTC
    @Scheduled(cron = "0 0 22 * * *", zone = "UTC")
    public void executeNightlyJob() {
        logger.info("Executing scheduled nightly data reconciliation job...");
        try {
            performReconciliation();
            logger.info("Nightly reconciliation job completed successfully.");
        } catch (Exception e) {
            logger.error("Critical failure during nightly reconciliation job", e);
        }
    }

    private void performReconciliation() throws Exception {
        // Simulate work execution
        Thread.sleep(10000);
    }
}

apiVersion: batch/v1
kind: CronJob
metadata:
  name: nightly-cleanup-job
  namespace: default
spec:
  schedule: "0 22 * * *"
  concurrencyPolicy: Forbid
  successfulJobsHistoryLimit: 3
  failedJobsHistoryLimit: 1
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: cleanup-worker
            image: busybox:1.36
            imagePullPolicy: IfNotPresent
            command:
            - /bin/sh
            - -c
            - "echo 'Starting daily system cleanup...'; sleep 30; echo 'Cleanup completed successfully!'"
            resources:
              limits:
                cpu: "500m"
                memory: "256Mi"
              requests:
                cpu: "100m"
                memory: "128Mi"
          restartPolicy: OnFailure