Linux CRON expresion CRON crontab Linux programacion de tareas automatizacion sysadmin

Guía de Expresiones CRON: Sintaxis, Ejemplos y Mejores Prácticas

Publicado el 3 de junio de 2026 · Niwo

¿Qué es una Expresión CRON?

Una expresión CRON es una cadena de cinco campos que define cuándo debe ejecutarse una tarea programada en sistemas operativos tipo Unix. CRON, el programador de tareas basado en tiempo de Linux y macOS, lee estas expresiones y ejecuta comandos en los momentos especificados.

CRON es la columna vertebral de la automatización de tareas en Linux. Los administradores de sistemas lo utilizan para programar copias de seguridad, rotar logs, ejecutar scripts de mantenimiento, enviar informes y desencadenar innumerables trabajos automatizados. Entender las expresiones CRON es esencial para cualquiera que administre servidores Linux.

La Sintaxis de Cinco Campos

Toda expresión CRON estándar consta de cinco campos separados por espacios:

graph LR
    M["minuto<br/>0-59"] --- H["hora<br/>0-23"] --- D["día del mes<br/>1-31"] --- MO["mes<br/>1-12"] --- W["día semana<br/>0-6"]
    style M fill:#1559ed,color:#fff
    style H fill:#1559ed,color:#fff
    style D fill:#1559ed,color:#fff
    style MO fill:#1559ed,color:#fff
    style W fill:#1559ed,color:#fff

Cada campo puede contener un valor específico, un rango, una lista, un valor de paso o el carácter comodín *.

Los meses y días de la semana también aceptan abreviaturas de tres letras: ENE, FEB, MAR, ABR, MAY, JUN, JUL, AGO, SEP, OCT, NOV, DIC para los meses, y DOM, LUN, MAR, MIÉ, JUE, VIE, SÁB para los días de la semana.

💡 Usa nuestra Calculadora CRON para visualizar lo que significa cualquier expresión en lenguaje natural y ver las próximas cinco fechas de ejecución.

Referencia de Sintaxis CRON

Entender el rango válido y el comportamiento de cada campo es la base para escribir expresiones CRON correctas.

Campo Minuto (0–59)

Controla el minuto exacto en que se ejecuta el comando. Es el campo más granular en una expresión CRON estándar de 5 campos.

• 0 — Se ejecuta al inicio de la hora
• 15 — Se ejecuta a los 15 minutos pasada la hora
• * — Se ejecuta cada minuto (usar con precaución)

Campo Hora (0–23)

Especifica la hora del día en formato de 24 horas.

• 0 — Medianoche
• 9 — 9:00 AM
• 22 — 10:00 PM
• * — Se ejecuta cada hora

Campo Día del Mes (1–31)

Define en qué día(s) del mes se ejecuta el trabajo.

• 1 — Primer día del mes
• 15 — Mitad del mes
• L — Último día del mes (no estándar, soportado por algunas implementaciones como Quartz)
• W — Día laborable más cercano al día dado (no estándar)

Campo Mes (1–12)

Especifica en qué mes(es) se ejecuta el trabajo. Acepta valores numéricos (1–12) o abreviaturas de tres letras (ENE–DIC).

• 1 o ENE — Enero
• 6 o JUN — Junio
• */3 — Cada tres meses (trimestral)

Campo Día de la Semana (0–6)

Especifica en qué día(s) de la semana se ejecuta el trabajo. Tanto 0 como 7 representan domingo en la mayoría de las implementaciones.

• 0 o 7 o DOM — Domingo
• 1–5 o LUN–VIE — Días laborables
• 6 o SÁB — Sábado
• L — Último día laborable del mes (no estándar)
• # — Enésima ocurrencia de un día laborable (ej., 5#2 = segundo viernes)

⚠️ Alerta CRON: Cuando se especifican tanto día-del-mes como día-de-la-semana (no *), el trabajo se ejecuta si cualquiera de las condiciones coincide. Esta es una fuente común de errores de programación.

Caracteres Especiales Explicados

Los caracteres especiales de CRON te dan control preciso sobre la programación sin necesidad de lógica compleja.

* — Comodín (Cualquier valor)

Coincide con todos los valores posibles del campo. * * * * * se ejecuta cada minuto de cada hora, todos los días de todos los meses.

0 * * * *    → minuto 0 de cada hora → se ejecuta cada hora

, — Lista (Múltiples Valores)

Especifica múltiples valores individuales en un mismo campo.

0,15,30,45 * * * *    → se ejecuta a los :00, :15, :30 y :45 de cada hora
0 9,18 * * LUN-VIE    → se ejecuta a las 9 AM y 6 PM en días laborables

- — Rango (Inclusivo)

Define un rango contiguo de valores.

0 9-17 * * *    → se ejecuta cada hora de 9 AM a 5 PM (9, 10, 11, ..., 17)
0 * 1-15 * *    → se ejecuta cada hora los días 1 al 15 del mes

/ — Paso (Cada N Unidades)

Salta valores a intervalos regulares. El lado izquierdo define el punto de partida; el lado derecho define el tamaño del paso.

*/5 * * * *      → cada 5 minutos (0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55)
0 */2 * * *      → cada 2 horas
0 0 */3 * *      → cada 3 días
0 0 * */3 *      → cada 3 meses (trimestral)

L — Último (No Estándar)

Representa la última ocurrencia. En el campo día-del-mes, L significa el último día del mes. En el campo día-de-la-semana, L después de un valor significa la última ocurrencia de ese día laborable.

0 0 L * *       → medianoche del último día de cada mes (Quartz, cronie)
0 0 * * 5L      → medianoche del último viernes de cada mes

Muchas implementaciones de cron estándar de Linux (Vixie cron, cronie) no soportan L, W o #. Estas son extensiones que se encuentran en el programador Quartz, Spring y algunos frameworks de Java. Siempre verifica la compatibilidad.

W — Día Laborable (No Estándar)

Encuentra el día laborable (lunes a viernes) más cercano al día del mes dado.

0 0 15W * *    → se ejecuta el día laborable más cercano al 15
               → si el 15 es sábado, se ejecuta el viernes 14
               → si el 15 es domingo, se ejecuta el lunes 16

# — Enésimo Día Laborable (No Estándar)

Especifica la enésima ocurrencia de un día laborable determinado en un mes.

0 0 * * 2#1    → primer lunes de cada mes (2 = lunes, #1 = primera ocurrencia)
0 0 * * 5#3    → tercer viernes de cada mes

Atajos CRON

Varios atajos nombrados simplifican los patrones de programación más comunes. Estos son azúcar sintáctica — se expanden a expresiones CRON estándar internamente.

@reboot es único: no está vinculado a un horario basado en tiempo. Los trabajos con @reboot se ejecutan una vez cuando cron se inicia, que típicamente ocurre al arrancar el sistema. Esto es útil para iniciar servicios, scripts de limpieza o inicializar estado.

# Ejemplo /etc/crontab usando atajos
@reboot root /usr/local/bin/iniciar-monitoreo.sh
@daily  root /usr/local/bin/rotar-logs.sh
@weekly root /usr/local/bin/backup-completo.sh

💡 Prueba estos atajos en nuestra Calculadora CRON para ver su forma expandida y sus próximas horas de ejecución.

Patrones CRON Comunes

Aquí hay quince expresiones CRON prácticas que cubren las necesidades de programación más frecuentes:

# Ejemplos comunes de crontab en producción
# Backup de base de datos diario a las 3 AM
0 3 * * * /usr/local/bin/backup-bd.sh

# Verificar uso de disco cada hora
0 * * * * /usr/local/bin/verificar-disco.sh

# Enviar informe semanal los lunes a las 8 AM
0 8 * * 1 /usr/local/bin/enviar-informe-semanal.sh

# Limpiar archivos temporales cada 6 horas
0 */6 * * * /usr/local/bin/limpiar-temp.sh

Cómo Probar Expresiones CRON

Antes de implementar un trabajo CRON en producción, es esencial probar la expresión. Una expresión mal escrita puede ejecutarse con demasiada frecuencia, en el momento equivocado o nunca.

Método 1: Usar una Calculadora CRON

La forma más rápida de probar una expresión es con una herramienta interactiva. Nuestra Calculadora CRON acepta cualquier expresión de 5 campos y muestra al instante:

• Descripción en lenguaje natural de lo que significa la expresión
• Próximas 5 fechas y horas de ejecución para verificar su corrección
• Constructor interactivo para crear expresiones campo por campo

Método 2: Probar con crontab.guru

El sitio web crontab.guru ofrece una forma rápida de verificar expresiones durante el desarrollo. Muestra una descripción legible para cualquier expresión CRON válida.

Método 3: Prueba en Seco con Variables de Entorno

Crea un script de prueba temporal que registre su ejecución:

# Crear un script de prueba
cat > /tmp/probar-cron.sh << 'EOF'
#!/bin/bash
echo "[$(date)] Trabajo CRON ejecutado con expresión: $@" >> /tmp/cron-prueba.log
EOF
chmod +x /tmp/probar-cron.sh

# Añadir una entrada crontab temporal (prueba de 5 minutos)
echo "*/5 * * * * /tmp/probar-cron.sh '*/5 * * * *'" | crontab -

# Revisar el log después de unos minutos
tail -f /tmp/cron-prueba.log

# Eliminar el trabajo de prueba al terminar
crontab -r

Método 4: Revisar los Logs del Sistema

Si un trabajo CRON parece no ejecutarse, revisa los logs del sistema:

# En Debian/Ubuntu
grep CRON /var/log/syslog

# En RHEL/CentOS
grep CRON /var/log/cron

# Filtrar por un comando específico
grep "backup-bd" /var/log/syslog

Método 5: Ejecutar el Comando Manualmente

Antes de programar, asegúrate de que el comando funciona de forma independiente:

# Ejecuta el comando exacto que planeas programar
/usr/local/bin/backup-bd.sh

# Verifica el código de salida (0 = éxito)
echo $?

💡 Nuestra Calculadora CRON es la herramienta de prueba más conveniente — no requiere instalación, funciona en cualquier navegador y traduce expresiones a lenguaje natural al instante.

Mejores Prácticas CRON

Seguir estas prácticas establecidas previene los fallos más comunes de CRON:

1. Usa Rutas Absolutas

CRON se ejecuta con un entorno mínimo. La variable PATH típicamente es /usr/bin:/bin. Tus scripts pueden fallar si dependen de comandos fuera de esta ruta.

# MAL — depende de PATH
0 3 * * * backup-bd.sh

# BIEN — usa rutas absolutas
0 3 * * * /usr/local/bin/backup-bd.sh

# MEJOR — establece PATH explícitamente dentro del script
# Dentro de /usr/local/bin/backup-bd.sh:
#   PATH=/usr/local/bin:/usr/bin:/bin

2. Redirige la Salida para Evitar Spam de Correo

Cada trabajo CRON que produce salida envía esa salida al buzón de correo del usuario por defecto. En servidores sin un MTA (agente de transferencia de correo) configurado, esto crea correo no entregable y desperdicia espacio en disco.

# Redirigir stdout y stderr a un archivo de log
0 3 * * * /usr/local/bin/backup-bd.sh >> /var/log/backup.log 2>&1

# Descartar silenciosamente toda la salida (usar con precaución — pierdes visibilidad de errores)
0 3 * * * /usr/local/bin/backup-bd.sh > /dev/null 2>&1

3. Incluye Logging

Siempre registra tus trabajos CRON. Cuando algo se rompe semanas después, el log es tu única pista.

#!/bin/bash
# Dentro de tu script
LOGFILE="/var/log/mi trabajo-$(date +\%Y\%m\%d).log"
echo "[$(date)] Iniciando trabajo" >> "$LOGFILE"

# Tu lógica de trabajo aquí

echo "[$(date)] Trabajo completado (salida: $?)" >> "$LOGFILE"

Nota los signos % escapados — en archivos crontab, % debe escaparse con una barra invertida.

4. Establece un Shebang Apropiado

Siempre inicia tus scripts con #!/bin/bash (o el intérprete correspondiente). CRON usa /bin/sh por defecto, que puede ser un shell limitado en algunos sistemas (Dash en Debian/Ubuntu).

5. Archivos de Bloqueo para Evitar Superposición

Si un trabajo tarda más que su intervalo, la siguiente invocación comienza antes de que la anterior termine. Esto puede causar condiciones de carrera, datos corruptos o sobrecarga del sistema.

#!/bin/bash
LOCKFILE="/tmp/mi trabajo.lock"

# Intentar adquirir el bloqueo
if ! mkdir "$LOCKFILE" 2>/dev/null; then
    echo "[$(date)] El trabajo ya está en ejecución. Saliendo."
    exit 1
fi

# Asegurar que el bloqueo se libera al salir
trap 'rm -rf "$LOCKFILE"' EXIT

# Lógica del trabajo aquí

6. Monitorea tus Trabajos CRON

Usa un enfoque de monitoreo que te alerte cuando los trabajos programados fallen:

• Healthchecks.io o Cronitor — monitoreo basado en HTTP que espera un ping en cada ejecución
• Ejecuta crontab -l regularmente — audita los trabajos programados
• Analiza archivos de log — busca códigos de salida distintos de cero
• Configura un heartbeat — un trabajo CRON que actualiza una marca de tiempo; alerta si la marca está desactualizada

7. Gestiona la Variable PATH Dentro de los Scripts

En lugar de depender del PATH predeterminado de CRON, establécelo explícitamente al inicio de tus scripts:

#!/bin/bash
PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
export PATH

Esto previene los errores de “comando no encontrado” que ocurren cuando CRON ejecuta scripts que dependen de configuraciones de PATH específicas del usuario.

Preguntas Frecuentes

¿Qué significa * * * * *?

* * * * * es la expresión CRON más básica — significa cada minuto de cada hora, todos los días, todos los meses, todos los días de la semana. Cada * actúa como comodín para su respectivo campo (minuto, hora, día del mes, mes, día de la semana). Esto es útil para pruebas pero rara vez apropiado para producción, ya que puede saturar los recursos del sistema si el comando adjunto no es ligero.

¿Cómo ejecutar CRON cada 30 minutos?

Para ejecutar un trabajo cada 30 minutos, usa: */30 * * * *. Esto se ejecuta en el minuto 0 y en el minuto 30 de cada hora. Alternativamente, puedes usar una lista: 0,30 * * * *, que produce el mismo resultado. Para cada 15 minutos, usa */15 * * * * (se ejecuta a los 0, 15, 30, 45). El carácter / (paso) hace que la programación por intervalos sea concisa y legible.

¿CRON vs systemd timers? ¿Cuál debería usar?

Las distribuciones modernas de Linux ofrecen dos sistemas de programación. Aquí tienes una comparativa:

Cuándo usar CRON: Trabajos recurrentes simples, scripts portables que se ejecutan en diferentes sistemas Unix, entornos heredados.

Cuándo usar systemd timers: Necesidades de programación complejas (retardos aleatorios, eventos de calendario), integración estrecha con servicios systemd, cuando necesitas registro a través de journald, o cuando necesitas aislamiento de recursos y sandboxing.

¿Qué es @reboot en CRON?

@reboot es un atajo especial de CRON que ejecuta un comando una vez cuando el daemon cron se inicia, lo que típicamente ocurre al arrancar el sistema. No es una expresión basada en tiempo. A diferencia de @daily o @hourly, @reboot no tiene una expresión equivalente de 5 campos porque está basado en eventos en lugar de tiempo. Se usa comúnmente para iniciar servicios de monitoreo, limpiar archivos temporales, inicializar estado de aplicaciones o ejecutar scripts de inicio. Ten en cuenta que @reboot no espera a que la red esté disponible — si tu script requiere conectividad de red, añade un retardo o un bucle de reintentos.

¿Cómo depurar CRON cuando no se ejecuta?

Si un trabajo CRON no se está ejecutando, sigue esta lista de verificación sistemática:

1. Verifica si cron está en ejecución: systemctl status cron (o crond en sistemas basados en RHEL).
2. Verifica el crontab: crontab -l para listar tus trabajos programados. Para crontabs del sistema, revisa /etc/crontab.
3. Verifica los permisos: El script debe ser ejecutable (chmod +x script.sh), y el usuario debe tener permiso para ejecutarlo.
4. Prueba el script manualmente: Ejecuta el comando exacto del crontab y verifica que funciona. El entorno de CRON es mínimo — lo que funciona en tu shell puede fallar en CRON.
5. Usa rutas absolutas: El PATH de CRON es limitado. Usa rutas completas tanto para comandos como para archivos.
6. Revisa los logs del sistema: grep CRON /var/log/syslog o journalctl -u cron para mensajes de error.
7. Verifica la expresión: Usa nuestra Calculadora CRON o crontab.guru para confirmar que la expresión produce el horario esperado.
8. Busca caracteres especiales: El carácter % tiene un significado especial en los archivos crontab y debe escaparse como \%.
9. Revisa los rebotes de correo: CRON envía la salida por correo. Revisa la salida del comando mail para obtener detalles del error.

Conclusión

Las expresiones CRON son una habilidad fundamental para la administración de sistemas Linux y la automatización de tareas. La sintaxis de cinco campos — minuto, hora, día del mes, mes y día de la semana — combinada con caracteres especiales como *, ,, - y /, te da un control preciso sobre cuándo se ejecutan tus trabajos.

En esta guía has aprendido:

• La sintaxis de 5 campos y el rango válido para cada campo
• Cómo los caracteres especiales expanden las posibilidades de programación
• Atajos nombrados como @daily y @reboot para patrones comunes
• 15 patrones CRON prácticos que cubren las necesidades de programación más frecuentes
• Métodos de prueba para validar expresiones antes de implementarlas
• Mejores prácticas para logging, gestión de PATH, monitoreo y evitar superposición
• Respuestas a las preguntas más frecuentes sobre CRON

¿Listo para poner este conocimiento en práctica?

Deja de adivinar tus expresiones CRON y empieza a verificarlas al instante:

• Calculadora CRON — Ingresa cualquier expresión de 5 campos, lee la descripción en lenguaje natural y ve las próximas cinco fechas de ejecución. Sin instalación requerida.
• Visualizador CRON — Ve tu programación en un calendario visual para detectar conflictos y confirmar los horarios de un vistazo.

Domina tus horarios, automatiza con confianza y no vuelvas a perder una copia de seguridad.