Cosa significa ogni campo cron?

I 5 campi sono: minuto, ora, giorno del mese, mese, giorno della settimana.

Come schedulare un task ogni 5 minuti?

Usa l'espressione */5 * * * * per eseguire ogni 5 minuti.

Cron Expression Builder: Generatore di Espressioni Cron Online

Le espressioni cron sono stringhe che definiscono quando eseguire task automatizzati su server Linux/Unix. Utilizzate da amministratori di sistema, DevOps e sviluppatori backend, le cron expression permettono di schedulare job ricorrenti con precisione al minuto.

Il nostro Cron Expression Builder è completamente gratuito, intuitivo e genera espressioni cron valide in tempo reale. Include spiegazione in linguaggio naturale, esempi comuni e supporto per sintassi a 5 e 6 campi.

Cos'è Cron e Come Funziona

Cron è un demone (servizio in background) presente in tutti i sistemi Unix/Linux che esegue comandi programmati a intervalli specifici. Il nome deriva dal greco "chronos" (tempo).

Anatomia di un'Espressione Cron

Un'espressione cron è composta da 5 o 6 campi separati da spazi:

┌───────────── minuto (0 - 59)
│ ┌───────────── ora (0 - 23)
│ │ ┌───────────── giorno del mese (1 - 31)
│ │ │ ┌───────────── mese (1 - 12)
│ │ │ │ ┌───────────── giorno della settimana (0 - 6) (Domenica=0)
│ │ │ │ │
│ │ │ │ │
* * * * * comando da eseguire

Esempio con 6 campi (include secondi):
│ │ │ │ │ │
│ │ │ │ │ └─── giorno della settimana (0 - 6)
│ │ │ │ └───── mese (1 - 12)
│ │ │ └─────── giorno del mese (1 - 31)
│ │ └───────── ora (0 - 23)
│ └─────────── minuto (0 - 59)
└───────────── secondo (0 - 59) [opzionale]

Caratteri Speciali

* (asterisco): Qualsiasi valore (es. `* * * * *` = ogni minuto)
, (virgola): Lista di valori (es. `1,15,30` = minuto 1, 15 e 30)
- (trattino): Intervallo (es. `1-5` = da 1 a 5)
/ (slash): Step/incremento (es. `*/5` = ogni 5 unità)
? (punto interrogativo): Nessun valore specifico (solo in giorno mese/settimana)
L: Ultimo (es. `L` nel giorno = ultimo giorno del mese)
W: Giorno lavorativo più vicino (es. `15W` = giorno lavorativo più vicino al 15)
#: N-esimo giorno (es. `2#3` = terzo martedì del mese)

Esempi di Espressioni Cron Comuni

Espressione	Descrizione	Quando Esegue
`* * * * *`	Ogni minuto	Ogni minuto di ogni ora
`0 * * * *`	Ogni ora	All'inizio di ogni ora (00:00, 01:00, 02:00...)
`0 0 * * *`	Ogni giorno a mezzanotte	00:00 ogni giorno
`0 2 * * *`	Ogni giorno alle 2:00	02:00 ogni giorno
`0 0 * * 0`	Ogni domenica a mezzanotte	00:00 ogni domenica
`0 0 1 * *`	Primo giorno di ogni mese	00:00 del 1° giorno del mese
`/5 * * *`	Ogni 5 minuti	00:00, 00:05, 00:10, 00:15...
`0 /2 * *`	Ogni 2 ore	00:00, 02:00, 04:00, 06:00...
`0 9-17 * * 1-5`	Ogni ora dalle 9 alle 17, lun-ven	Orario lavorativo 9-17 nei giorni feriali
`0 0 * * 1`	Ogni lunedì a mezzanotte	00:00 ogni lunedì
`0 3 1,15 * *`	1° e 15° giorno del mese alle 3:00	03:00 il 1° e 15 del mese
`30 4 1 1 *`	Capodanno alle 4:30	04:30 del 1° gennaio

Casi d'Uso delle Espressioni Cron

1. Backup Automatici

Schedulare backup di database, file, configurazioni:

# Backup database ogni giorno alle 2:00 AM
0 2 * * * /usr/local/bin/backup-db.sh

# Backup completo ogni domenica alle 3:00 AM
0 3 * * 0 /usr/local/bin/full-backup.sh

# Backup incrementale ogni 6 ore
0 */6 * * * /usr/local/bin/incremental-backup.sh

Caso pratico: Server di produzione che fa backup del database PostgreSQL ogni notte e upload su S3.

2. Pulizia e Manutenzione

Rimuovere file temporanei, log vecchi, cache:

# Pulizia log più vecchi di 7 giorni, ogni domenica alle 4:00
0 4 * * 0 find /var/log -name "*.log" -mtime +7 -delete

# Svuotare cache ogni giorno a mezzanotte
0 0 * * * rm -rf /tmp/cache/*

# Vacuum database PostgreSQL ogni lunedì alle 3:00
0 3 * * 1 psql -U postgres -d mydb -c "VACUUM ANALYZE;"

Caso pratico: Sistema che accumula log, richiede pulizia settimanale per evitare riempimento disco.

3. Report e Analytics

Generare report periodici, statistiche, email riassuntive:

# Report vendite giornaliero alle 8:00 AM
0 8 * * * /usr/local/bin/generate-daily-sales-report.sh

# Report settimanale ogni venerdì alle 17:00
0 17 * * 5 /usr/local/bin/weekly-summary.sh

# Report mensile il primo giorno del mese alle 9:00
0 9 1 * * /usr/local/bin/monthly-report.sh

Caso pratico: E-commerce che invia report vendite giornalieri al management via email.

4. Sincronizzazione Dati

Sincronizzare database, file, cache tra sistemi:

# Sync files da server remoto ogni 15 minuti
*/15 * * * * rsync -avz user@remote:/data /local/data

# Sync database replica ogni ora
0 * * * * /usr/local/bin/sync-db-replica.sh

# Aggiornare cache da API ogni 5 minuti
*/5 * * * * curl -X POST https://api.example.com/refresh-cache

Caso pratico: CDN che sincronizza contenuti statici da origin server ogni 10 minuti.

5. Monitoraggio e Health Checks

Verificare stato servizi, inviare alert, controllare metriche:

# Health check servizi ogni 5 minuti
*/5 * * * * /usr/local/bin/health-check.sh

# Monitoring disk space ogni ora
0 * * * * df -h | mail -s "Disk Space Report" admin@example.com

# Check certificati SSL scaduti ogni giorno alle 6:00
0 6 * * * /usr/local/bin/check-ssl-certs.sh

Caso pratico: Sistema di monitoring che verifica uptime di 50 microservizi ogni 2 minuti.

6. Task di Sistema e DevOps

Riavvii, aggiornamenti, deploy automatici:

# Riavvio servizio ogni giorno alle 4:00 (per memory leak fix)
0 4 * * * systemctl restart myapp.service

# Aggiornamento sistema ogni domenica alle 5:00
0 5 * * 0 apt update && apt upgrade -y

# Deploy automatico da Git ogni 30 minuti (CI/CD)
*/30 * * * * cd /var/www/app && git pull && npm install && pm2 restart app

7. Notifiche e Reminder

Inviare email, SMS, notifiche push programmate:

# Email reminder ogni lunedì alle 9:00
0 9 * * 1 echo "Weekly standup at 10:00" | mail -s "Reminder" team@example.com

# Notifica scadenze contratti 7 giorni prima
0 10 * * * /usr/local/bin/contract-expiry-check.sh

# Invio newsletter ogni giovedì alle 14:00
0 14 * * 4 /usr/local/bin/send-newsletter.sh

Come Usare il Cron Builder di THEJORD

Interfaccia Visuale

Apri il Cron Expression Builder
Seleziona frequenza tramite controlli visivi:
- Minuti: Scegli minuto specifico o intervallo (*/5, */10, */15)
- Ore: Seleziona ora o range (9-17 per orario lavorativo)
- Giorni del mese: Scegli giorni specifici (1, 15) o tutti (*)
- Mesi: Seleziona mesi o tutti (*)
- Giorni della settimana: Scegli giorni (1=Lun, 5=Ven, 0=Dom)
Vedi espressione generata in tempo reale
Leggi descrizione in italiano (es. "Ogni giorno alle 2:00 AM")
Copia espressione con un click

Modalità Avanzata

Sintassi 6 campi: Abilita per includere i secondi (Quartz, Spring)
Preset comuni: Carica template predefiniti (ogni ora, ogni giorno, settimanale)
Test next runs: Visualizza prossime 10 esecuzioni con date/ore
Validazione: Controlla se espressione è valida
Conversione timezone: Mostra orari in UTC/Local

Esempio Pratico: Backup Database Notturno

// Obiettivo: Backup database ogni notte alle 3:00 AM

1. Minuti: 0
2. Ore: 3
3. Giorni del mese: * (ogni giorno)
4. Mesi: * (tutti i mesi)
5. Giorni settimana: * (tutti i giorni)

Risultato: 0 3 * * *
Descrizione: "Alle 3:00 AM ogni giorno"

Prossime esecuzioni:
- 2024-12-03 03:00:00
- 2024-12-04 03:00:00
- 2024-12-05 03:00:00

Esempi di Codice e Implementazioni

Linux Crontab

# Modificare crontab per utente corrente
crontab -e

# Aggiungere job cron
0 2 * * * /home/user/backup.sh

# Vedere crontab corrente
crontab -l

# Rimuovere tutti i cron job
crontab -r

# Crontab di sistema (richiede sudo)
sudo nano /etc/crontab

# Logs cron (per debugging)
tail -f /var/log/syslog | grep CRON

Node.js con node-cron

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

// Backup database ogni giorno alle 2:00
cron.schedule('0 2 * * *', () => {
  console.log('Running database backup...');
  require('./backup-db')();
});

// Pulizia cache ogni 5 minuti
cron.schedule('*/5 * * * *', () => {
  console.log('Clearing cache...');
  cache.clear();
});

// Report settimanale ogni venerdì alle 17:00
cron.schedule('0 17 * * 5', () => {
  console.log('Generating weekly report...');
  generateReport();
}, {
  timezone: "Europe/Rome"
});

Python con schedule

import schedule
import time

def backup_database():
    print("Running backup...")
    # backup logic

def send_report():
    print("Sending report...")
    # report logic

# Backup ogni giorno alle 2:00
schedule.every().day.at("02:00").do(backup_database)

# Report ogni lunedì alle 9:00
schedule.every().monday.at("09:00").do(send_report)

# Pulizia ogni 5 minuti
schedule.every(5).minutes.do(lambda: print("Cleaning..."))

while True:
    schedule.run_pending()
    time.sleep(60)

Spring Boot con @Scheduled

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@Component
public class ScheduledTasks {

    // Backup ogni giorno alle 2:00
    @Scheduled(cron = "0 0 2 * * *")
    public void backupDatabase() {
        System.out.println("Running backup...");
        // backup logic
    }

    // Report ogni lunedì alle 9:00
    @Scheduled(cron = "0 0 9 * * MON")
    public void sendWeeklyReport() {
        System.out.println("Sending weekly report...");
        // report logic
    }

    // Pulizia ogni 5 minuti (6 campi con secondi)
    @Scheduled(cron = "0 */5 * * * *")
    public void cleanCache() {
        System.out.println("Cleaning cache...");
        // cleanup logic
    }
}

Kubernetes CronJob

apiVersion: batch/v1
kind: CronJob
metadata:
  name: database-backup
spec:
  schedule: "0 2 * * *"  # Ogni giorno alle 2:00
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: backup
            image: postgres:15
            command:
            - /bin/sh
            - -c
            - pg_dump -U postgres mydb > /backup/dump.sql
          restartPolicy: OnFailure

Confronto Alternative a Cron

Sistema	Sintassi	Precisione	Persistenza	Logging
Cron (Unix)	5 campi	Minuto	✅ Crontab	Syslog
Quartz (Java)	6-7 campi	Secondo	✅ Database	Log4j
systemd timers	Unit files	Microsecondo	✅ Service files	Journalctl
node-cron	5-6 campi	Secondo	❌ In-memory	Console
Kubernetes CronJob	5 campi	Minuto	✅ YAML	kubectl logs

Quando Usare Cosa

Cron tradizionale: Server Linux/Unix, task semplici, script shell
systemd timers: Linux moderno, preferibile a cron per integrazione sistema
Quartz/Spring: Applicazioni Java enterprise con scheduling complesso
node-cron: Applicazioni Node.js, task in-process
Kubernetes CronJob: Workload containerizzati, microservizi cloud-native

Best Practices e Troubleshooting

✅ Best Practices

Path assoluti: Usa sempre path completi nei comandi cron
Logging: Redireziona output per debugging: command >> /var/log/cron.log 2>&1
Lock files: Previeni esecuzioni sovrapposte con flock
Timeout: Usa timeout per evitare processi bloccati
Email notifications: Configura MAILTO per ricevere errori
Test prima: Testa script manualmente prima di schedularlo

⚠️ Problemi Comuni

Problema: Cron job non si esegue

# Verifica se cron service è attivo
systemctl status cron

# Controlla syntax errors in crontab
crontab -l

# Vedi log cron per errori
tail -f /var/log/syslog | grep CRON

Problema: Script funziona manualmente ma non da cron

Causa: Environment variables diverse (PATH, HOME, USER)
Soluzione: Imposta variabili in crontab o script

# In crontab, definisci environment
PATH=/usr/local/bin:/usr/bin:/bin
HOME=/home/user

0 2 * * * /home/user/script.sh

Problema: Esecuzioni duplicate

Causa: Job precedente ancora in esecuzione quando inizia il prossimo
Soluzione: Usa flock per lock file

*/5 * * * * flock -n /tmp/myjob.lock /usr/local/bin/myjob.sh

Domande Frequenti (FAQ)

Qual è la differenza tra cron a 5 e 6 campi?

Cron tradizionale Unix usa 5 campi (minuto-ora-giorno-mese-settimana) con precisione al minuto. Quartz e Spring usano 6 campi aggiungendo i secondi all'inizio, permettendo precisione al secondo.

Posso eseguire un cron job ogni secondo?

No con cron tradizionale (minimo 1 minuto). Sì con Quartz/Spring (6 campi con secondi) o systemd timers. Per task sub-minuto su Linux, usa systemd timer o loop in script.

Come eseguire un job solo nei giorni feriali?

0 9 * * 1-5  # Lun-Ven alle 9:00

# Oppure escludendo sabato e domenica
0 9 * * 1,2,3,4,5

Cosa significa */5 nelle espressioni cron?

"Ogni 5 unità". Esempio: `*/5` nei minuti = ogni 5 minuti (0, 5, 10, 15...). `*/2` nelle ore = ogni 2 ore (0, 2, 4, 6...).

Come eseguire un job l'ultimo giorno del mese?

# Non esiste sintassi standard in cron Unix
# Workaround con script che controlla la data
0 0 * * * [ $(date -d tomorrow +\%d) -eq 1 ] && /path/to/script.sh

# Oppure usa Quartz che supporta "L"
0 0 L * *  # Quartz syntax

Cron rispetta l'ora legale?

Sì, cron usa l'ora di sistema locale. Durante il cambio ora legale, un job schedulato alle 2:30 potrebbe eseguire 0, 1 o 2 volte. Per evitare problemi, usa orari lontani dal cambio (1:00-2:00).

Come faccio il debug di un cron job che fallisce?

# 1. Redireziona output su file
0 2 * * * /path/script.sh >> /var/log/myjob.log 2>&1

# 2. Aggiungi set -x allo script per debug
#!/bin/bash
set -x  # Debug mode
echo "Starting job..."

# 3. Controlla email (cron invia output via mail)
# Configura in crontab:
MAILTO=admin@example.com

Risorse Correlate

Esplora altri strumenti utili di THEJORD:

RegEx Tester: Testa pattern regex per validare output di cron job
JSON Formatter: Formatta JSON prodotto da script schedulati
Diff Checker: Confronta output di cron job tra esecuzioni
Hash Generator: Verifica integrità file generati da backup automatici

Documentazione Esterna

Prova il Cron Builder Ora →