Generatore di espressioni Cron

Cos'è un generatore di espressioni cron?

Un generatore di espressioni cron è uno strumento che costruisce stringhe di pianificazione cron tramite un'interfaccia visuale, senza richiedere di scriverle a mano. Le espressioni cron sono stringhe a cinque campi (minuto, ora, giorno del mese, mese, giorno della settimana) che definiscono quando deve essere eseguito un task ricorrente. Il formato risale al demone cron Unix originale del 1979 ed è oggi utilizzato in crontab, Kubernetes CronJobs, GitHub Actions, AWS EventBridge, Google Cloud Scheduler e decine di librerie di scheduling.

Scrivere espressioni cron a memoria è una fonte comune di bug. I cinque campi interagiscono in modi non ovvi: un valore di passo come */15 nel campo dei minuti produce esecuzioni a 0, 15, 30 e 45, mentre 5/15 parte dal minuto 5 e produce 5, 20, 35, 50. Combinare giorno del mese e giorno della settimana con valori non wildcard crea una condizione OR, non AND, il che sorprende anche gli sviluppatori più esperti. Un generatore visuale elimina questa ambiguità lasciandoti selezionare la pianificazione desiderata e producendo automaticamente la sintassi corretta.

Un generatore cron si differenzia da un parser cron. Un parser prende un'espressione esistente e la spiega in linguaggio naturale. Un generatore funziona nella direzione opposta: descrivi la pianificazione di cui hai bisogno e lo strumento produce la stringa cron corrispondente. Usa il generatore quando crei un nuovo job pianificato; usa il parser quando auditi o esegui il debug di quelli esistenti.

Perché usare questo generatore cron?

Costruire un'espressione cron a mano significa memorizzare l'ordine dei campi, i range di valori e le regole degli operatori. Un singolo campo fuori posto trasforma un job giornaliero in uno che viene eseguito ogni minuto. Questo generatore ti permette di scegliere la pianificazione visualmente e copiare il risultato con un clic.

Casi d'uso del generatore cron

Preset comuni per le pianificazioni cron

La tabella seguente elenca le espressioni cron per le pianificazioni più utilizzate. La maggior parte dei job in produzione rientra in uno di questi schemi. Modifica i singoli campi per adattarli alle tue esigenze temporali.

Elementi costitutivi di un'espressione cron

Ogni espressione cron ha esattamente cinque campi, letti da sinistra a destra. Ogni campo accetta valori e operatori specifici. Conoscere queste regole è sufficiente per scrivere qualsiasi pianificazione che potresti incontrare in produzione.

Quattro operatori controllano come vengono confrontati i valori all'interno di ogni campo. Puoi combinarli: 1-5/2 nel campo giorno della settimana significa lunedì, mercoledì, venerdì (range 1-5, passo di 2).

Esempi di codice

Come creare e registrare pianificazioni cron in Node.js, Python, Go e bash:

import { CronJob } from 'cron';

// Build a cron expression: every weekday at 9:00 AM
const expression = '0 9 * * 1-5';

const job = new CronJob(expression, () => {
  console.log('Running weekday morning task');
});
job.start();

// Programmatic expression building
function buildCron({ minute = '*', hour = '*', dom = '*', month = '*', dow = '*' }) {
  return `${minute} ${hour} ${dom} ${month} ${dow}`;
}

const expr = buildCron({ minute: '0', hour: '*/6', dow: '1-5' });
console.log(expr); // → "0 */6 * * 1-5"

from crontab import CronTab

# Create a new cron job for the current user
cron = CronTab(user=True)

# Build a job: run backup.py every day at 2:30 AM
job = cron.new(command='python3 /home/user/backup.py')
job.setall('30 2 * * *')

print(job)           # → 30 2 * * * python3 /home/user/backup.py
print(job.is_valid()) # → True

# Schedule every 15 minutes on weekdays
job2 = cron.new(command='/usr/bin/sync-data')
job2.minute.every(15)
job2.dow.during('MON', 'FRI')

cron.write()  # Save to user's crontab

# Verify next run time
from croniter import croniter
from datetime import datetime

it = croniter('30 2 * * *', datetime.now())
print(it.get_next(datetime))  # → next 2:30 AM timestamp

package main

import (
    "fmt"
    "strings"
    "github.com/robfig/cron/v3"
)

// BuildCron constructs a 5-field cron expression from parts
func BuildCron(minute, hour, dom, month, dow string) string {
    fields := []string{minute, hour, dom, month, dow}
    return strings.Join(fields, " ")
}

func main() {
    // Generate: every weekday at 9 AM
    expr := BuildCron("0", "9", "*", "*", "1-5")
    fmt.Println(expr) // → 0 9 * * 1-5

    // Validate and schedule it
    c := cron.New()
    _, err := c.AddFunc(expr, func() {
        fmt.Println("Running scheduled task")
    })
    if err != nil {
        fmt.Printf("Invalid expression: %v\n", err)
        return
    }
    c.Start()
}

# Open the crontab editor to add a new job
crontab -e

# Add a cron job without opening an editor:
# Run cleanup.sh every Sunday at 3 AM
(crontab -l 2>/dev/null; echo "0 3 * * 0 /home/user/cleanup.sh") | crontab -

# Generate and add a job: every 10 minutes, log disk usage
EXPR="*/10 * * * *"
CMD="df -h >> /var/log/disk-usage.log"
(crontab -l 2>/dev/null; echo "$EXPR $CMD") | crontab -

# Verify the job was added
crontab -l | tail -1
# → */10 * * * * df -h >> /var/log/disk-usage.log

# Remove all cron jobs (use with caution)
# crontab -r

Domande frequenti