Run Jobs Every Six Hours at Minute Zero | CronBase

const cron = require('node-cron');

// Schedule a task to run every six hours (at minute 0)
cron.schedule('0 */6 * * *', () => {
  try {
    console.log(`[${new Date().toISOString()}] Starting 6-hour system diagnostics run.`);
    // Implement your application-specific cleanup or sync logic here
  } catch (error) {
    console.error('Error executing 6-hour scheduled job:', error);
  }
}, {
  scheduled: true,
  timezone: "Etc/UTC"
});

#!/bin/bash
# Production deployment script to install a 6-hour maintenance cron job
set -euo pipefail

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

# Safely add the job to crontab without duplicating existing entries
(crontab -l 2>/dev/null | grep -Fv "/usr/local/bin/backup-cleanup.sh"; echo "$CRON_JOB") | crontab -
echo "Cron job successfully deployed to crontab."

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

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

def perform_sync():
    try:
        logger.info("Starting 6-hour database synchronization routine.")
    except Exception as e:
        logger.error(f"Task failed: {e}", exc_info=True)

scheduler = BlockingScheduler()
# Trigger matches standard cron: 0 */6 * * *
scheduler.add_job(perform_sync, 'cron', hour='*/6', minute=0, timezone='UTC')

try:
    logger.info("Scheduler started. Waiting for execution...")
    scheduler.start()
except (KeyboardInterrupt, SystemExit):
    logger.info("Scheduler stopped.")
    sys.exit(0)

package main

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

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

func main() {
	// Use UTC timezone to avoid DST shift anomalies
	c := cron.New(cron.WithLocation(cron.UTC))
	
	_, err := c.AddFunc("0 */6 * * *", func() {
		log.Println("Executing 6-hour API synchronization routine...")
	})
	if err != nil {
		log.Fatalf("Error scheduling cron job: %v", err)
	}

	c.Start()
	fmt.Println("Cron scheduler initialized. Press Ctrl+C to exit.")

	sigChan := make(chan os.Signal, 1)
	signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
	<-sigChan
	c.Stop()
	log.Println("Scheduler stopped cleanly.")
}

package com.example.cron;

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

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

    // Spring's cron format includes seconds as the first field: "0 0 */6 * * *"
    @Scheduled(cron = "0 0 */6 * * *", zone = "UTC")
    public void executeTask() {
        try {
            logger.info("Starting scheduled 6-hour cache warming procedure.");
            // Execute business logic here
        } catch (Exception e) {
            logger.severe("Cache warming execution failed: " + e.getMessage());
        }
    }
}

apiVersion: batch/v1
kind: CronJob
metadata:
  name: six-hour-cleanup-job
  namespace: default
spec:
  schedule: "0 */6 * * *"
  concurrencyPolicy: Forbid
  successfulJobsHistoryLimit: 3
  failedJobsHistoryLimit: 1
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: cleanup-worker
            image: alpine:latest
            command: ["/bin/sh", "-c", "echo 'Cleaning database logs...'; sleep 10"]
          restartPolicy: OnFailure