Run Daily 3 AM Database Backups | CronBase

#!/usr/bin/env bash
# Crontab entry: 0 3 * * * /usr/local/bin/daily_backup.sh
set -euo pipefail

LOCKFILE="/var/tmp/daily_backup.lock"

# Prevent concurrent execution of the daily 3 AM backup
exec 9>"$LOCKFILE"
if ! flock -n 9; then
    echo "Error: Another backup process is already running." >&2
    exit 1
fi

echo "Starting daily maintenance at $(date)"
# Perform backup operations here
/usr/local/bin/backup_db.sh --output /mnt/backups/daily/

echo "Daily maintenance completed successfully."

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

// Schedule task to run daily at 3:00 AM UTC to avoid DST anomalies
cron.schedule('0 3 * * *', () => {
    console.log(`[${new Date().toISOString()}] Initiating daily 3 AM database cleanup...`);
    
    exec('/usr/local/bin/cleanup-logs.sh', (error, stdout, stderr) => {
        if (error) {
            console.error(`Execution error: ${error.message}`);
            return;
        }
        if (stderr) {
            console.warn(`Stderr: ${stderr}`);
        }
        console.log(`Stdout: ${stdout}`);
        console.log(`[${new Date().toISOString()}] Daily cleanup finished successfully.`);
    });
}, {
    scheduled: true,
    timezone: "UTC"
});

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

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger("daily_scheduler")

def run_daily_task():
    logger.info("Starting daily 3 AM maintenance task at %s", datetime.utcnow())
    try:
        # Business logic goes here
        pass
    except Exception as e:
        logger.error("Daily task failed: %s", str(e), exc_info=True)

if __name__ == "__main__":
    scheduler = BlockingScheduler(timezone="UTC")
    # 0 3 * * * translates to hour=3, minute=0 daily
    scheduler.add_job(run_daily_task, 'cron', hour=3, minute=0)
    logger.info("Scheduler started. Running daily task at 3:00 AM UTC.")
    try:
        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 prevent DST anomalies at 3 AM
	nyc, err := time.LoadLocation("UTC")
	if err != nil {
		log.Fatalf("Failed to load timezone: %v", err)
	}

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

	// 0 3 * * * represents daily at 3:00 AM
	_, err = c.AddFunc("0 3 * * *", func() {
		log.Println("Daily 3:00 AM cron job started.")
		executeBackup()
	})
	if err != nil {
		log.Fatalf("Error scheduling cron job: %v", err)
	}

	c.Start()
	log.Println("Cron scheduler initialized for 3 AM daily run.")

	sigChan := make(chan os.Signal, 1)
	signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
	<-sigChan
	c.Stop()
}

func executeBackup() {
	// Implementation of daily database or log maintenance
	log.Println("Backup complete.")
}

package com.cronbase.scheduler;

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

@Component
public class DailyMaintenanceScheduler {

    private static final Logger LOGGER = Logger.getLogger(DailyMaintenanceScheduler.class.getName());

    // Spring cron format: "second minute hour day-of-month month day-of-week"
    @Scheduled(cron = "0 0 3 * * *", zone = "UTC")
    public void executeDailyTask() {
        LOGGER.info("Starting daily maintenance routine at " + Instant.now());
        try {
            performDatabaseCleanup();
            LOGGER.info("Daily maintenance completed successfully.");
        } catch (Exception e) {
            LOGGER.severe("Failed to execute daily maintenance: " + e.getMessage());
        }
    }

    private void performDatabaseCleanup() {
        // Business logic here
    }
}

apiVersion: batch/v1
kind: CronJob
metadata:
  name: daily-backup-3am
  namespace: infrastructure
spec:
  schedule: "0 3 * * *"
  concurrencyPolicy: Forbid
  successfulJobsHistoryLimit: 3
  failedJobsHistoryLimit: 5
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: database-exporter
            image: postgres:15-alpine
            command:
            - /bin/sh
            - -c
            - "pg_dump -h db.prod -U postgres prod_db | gzip > /mnt/backups/db-$(date +%F).sql.gz"
            volumeMounts:
            - name: backup-volume
              mountPath: /mnt/backups
          restartPolicy: OnFailure
          volumes:
          - name: backup-volume
            persistentVolumeClaim:
              claimName: backup-pvc