Run Sunday at 1 AM Cron Schedule Guide | CronBase

#!/usr/bin/env bash
# Weekly system backup cron job scheduled for 1:00 AM on Sundays
set -euo pipefail

LOG_FILE="/var/log/weekly_backup.log"

log() {
    echo "[$(date +'%Y-%m-%dT%H:%M:%S%z')] $1" >> "$LOG_FILE"
}

log "Starting weekly backup process..."

# Perform backup operation
if tar -czf /backups/weekly_$(date +%F).tar.gz /data >> "$LOG_FILE" 2>&1; then
    log "Backup completed successfully."
else
    log "ERROR: Backup failed!"
    exit 1
fi

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

// Schedule task to run every Sunday at 1:00 AM
cron.schedule('0 1 * * 0', () => {
  console.log(`[${new Date().toISOString()}] Initiating weekly database maintenance...`);

  exec('npm run db:maintenance', (error, stdout, stderr) => {
    if (error) {
      console.error(`Maintenance failed: ${error.message}`);
      return;
    }
    if (stderr) {
      console.warn(`Maintenance warnings: ${stderr}`);
    }
    console.log(`Maintenance output: ${stdout}`);
  });
}, {
  scheduled: true,
  timezone: "UTC"
});

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

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

def weekly_cleanup_job():
    logger.info("Starting weekly cleanup and optimization job...")
    try:
        # Simulate cleanup logic
        logger.info("Database indexes rebuilt successfully.")
    except Exception as e:
        logger.error(f"Cleanup job failed: {str(e)}")

if __name__ == "__main__":
    scheduler = BlockingScheduler()
    # 0 1 * * 0 translates to day_of_week='sun', hour=1, minute=0
    scheduler.add_job(weekly_cleanup_job, 'cron', day_of_week='sun', hour=1, minute=0, timezone='UTC')
    logger.info("Scheduler started. Job configured for Sundays at 1:00 AM UTC.")
    try:
        scheduler.start()
    except (KeyboardInterrupt, SystemExit):
        logger.info("Scheduler stopped.")

package main

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

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

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

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

	// 0 1 * * 0: Every Sunday at 1:00 AM
	_, err = c.AddFunc("0 1 * * 0", func() {
		fmt.Printf("[%s] Running weekly report generation...\n", time.Now().Format(time.RFC3339))
		// Implement report generation logic here
	})
	if err != nil {
		log.Fatalf("Error scheduling job: %v", err)
	}

	c.Start()
	log.Println("Cron scheduler started. Waiting for Sunday at 1:00 AM...")

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

	log.Println("Shutting down scheduler...")
	c.Stop()
}

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 WeeklyMaintenanceScheduler {

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

    // "0 1 * * 0" in standard cron translates to "0 0 1 * * SUN" in Spring (which includes seconds)
    @Scheduled(cron = "0 0 1 * * SUN", zone = "UTC")
    public void runWeeklyMaintenance() {
        logger.info("Weekly maintenance job started at 1:00 AM Sunday UTC");
        try {
            performDatabaseVacuum();
            logger.info("Weekly maintenance completed successfully.");
        } catch (Exception e) {
            logger.error("Error during weekly maintenance execution", e);
        }
    }

    private void performDatabaseVacuum() {
        // Logic to optimize database storage
    }
}

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