Run Every 12 Hours Cron Schedule | CronBase

#!/usr/bin/env bash
# System cron job implementation for twice-daily database backup
# Typically installed in /etc/cron.d/db-backup or via crontab -e

set -euo pipefail

BACKUP_DIR="/var/backups/postgres"
LOG_FILE="/var/log/db-backup.log"

# Ensure backup directory exists
mkdir -p "${BACKUP_DIR}"

echo "[$(date -u +'%Y-%m-%dT%H:%M:%SZ')] Starting semi-daily database backup..." >> "${LOG_FILE}"

# Execute backup with error handling
if pg_dump -U postgres prod_db | gzip > "${BACKUP_DIR}/db_backup_$(date +%Y%m%d_%H%M%S).sql.gz"; then
    echo "[$(date -u +'%Y-%m-%dT%H:%M:%SZ')] Backup completed successfully." >> "${LOG_FILE}"
else
    echo "[$(date -u +'%Y-%m-%dT%H:%M:%SZ')] ERROR: Database backup failed!" >&2
    # Send alert to monitoring system here (e.g., PagerDuty or curl webhook)
    exit 1
fi

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

// Schedule task to run twice daily at midnight and noon (0 */12 * * *)
const schedule = '0 */12 * * *';

const job = cron.schedule(schedule, () => {
    console.log(`[${new Date().toISOString()}] Initiating 12-hour cache invalidation and data sync...`);
    
    exec('npm run sync-cache', (error, stdout, stderr) => {
        if (error) {
            console.error(`[${new Date().toISOString()}] Sync failed:`, error.message);
            // Implement alerting/notification logic here
            return;
        }
        if (stderr) {
            console.warn(`[${new Date().toISOString()}] Sync warning:`, stderr);
        }
        console.log(`[${new Date().toISOString()}] Sync completed:`, stdout.trim());
    });
}, {
    scheduled: true,
    timezone: "UTC"
});

job.start();

import logging
import sys
from datetime import datetime
from apscheduler.schedulers.blocking import BlockingScheduler
from apscheduler.triggers.cron import CronTrigger

logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s [%(levelname)s] %(message)s',
    handlers=[logging.StreamHandler(sys.stdout)]
)

def execute_semi_daily_cleanup():
    logging.info("Starting 12-hour temporary file cleanup process...")
    try:
        # Business logic simulation
        # perform_cleanup()
        logging.info("Temporary file cleanup completed successfully.")
    except Exception as e:
        logging.error(f"Cleanup failed: {str(e)}", exc_info=True)
        # Trigger alert notifications here

if __name__ == "__main__":
    scheduler = BlockingScheduler()
    # 0 */12 * * * mapped to CronTrigger (minute=0, hour='*/12')
    trigger = CronTrigger(minute=0, hour='*/12', timezone='UTC')
    
    scheduler.add_job(
        execute_semi_daily_cleanup,
        trigger=trigger,
        id='semi_daily_cleanup_job',
        replace_existing=True
    )
    
    logging.info("Scheduler started. Job configured for twice-daily execution (0 */12 * * *).")
    try:
        scheduler.start()
    except (KeyboardInterrupt, SystemExit):
        logging.info("Scheduler stopped cleanly.")

package main

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

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

func runSemiDailySync() {
    log.Printf("[%s] Starting 12-hour data pipeline synchronization...", time.Now().UTC().Format(time.RFC3339))
    // Simulate processing
    time.Sleep(5 * time.Second)
    log.Printf("[%s] Data pipeline synchronization complete.", time.Now().UTC().Format(time.RFC3339))
}

func main() {
    // Use UTC timezone to prevent DST shift anomalies
    c := cron.New(cron.WithLocation(time.UTC))

    // Standard cron: 0 */12 * * *
    _, err := c.AddFunc("0 */12 * * *", runSemiDailySync)
    if err != nil {
        log.Fatalf("Failed to schedule cron job: %v", err)
    }

    c.Start()
    log.Println("Cron scheduler started. Running twice-daily tasks (0 */12 * * *)...")

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

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

package com.example.cron;

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

@Component
public class SemiDailyMaintenanceTask {

    private static final Logger log = LoggerFactory.getLogger(SemiDailyMaintenanceTask.class);

    // standard cron: 0 */12 * * * (Spring uses standard 6-field/5-field macro or standard cron string)
    // In Spring, "0 0 */12 * * *" represents second=0, minute=0, hour=every 12th hour.
    @Scheduled(cron = "0 0 */12 * * *", zone = "UTC")
    public void executeMaintenance() {
        log.info("Starting twice-daily database index optimization...");
        try {
            // Business logic goes here
            // indexService.rebuildIndexes();
            log.info("Database index optimization completed successfully.");
        } catch (Exception e) {
            log.error("Critical failure during semi-daily maintenance: ", e);
            // Invoke alert system / dead man's switch notification
        }
    }
}

apiVersion: batch/v1
kind: CronJob
metadata:
  name: database-vacuum-job
  namespace: infrastructure
spec:
  schedule: "0 */12 * * *"
  concurrencyPolicy: Forbid
  successfulJobsHistoryLimit: 3
  failedJobsHistoryLimit: 5
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: postgres-vacuum
            image: postgres:15-alpine
            command: 
            - /bin/sh
            - -c
            - |
              echo "Starting database vacuum process..."
              psql -h $DB_HOST -U $DB_USER -d $DB_NAME -c "VACUUM ANALYZE;"
            env:
            - name: DB_HOST
              value: "postgres-service.database.svc.cluster.local"
            - name: DB_USER
              value: "postgres"
            - name: DB_NAME
              value: "production"
          restartPolicy: OnFailure