systemd timers en lugar de cron: análisis profundo de la programación de tareas en LinuxA fondo · digest del 6 de noviembre
Espacio de trabajo de un ingeniero Linux con una terminal abierta mostrando la lista de temporizadores systemd, una libreta con el esquema de unidades emparejadas y un temporizador de escritorio.
A fondo7 secciones≈ 13 min

systemd timers en lugar de cron: análisis profundo de la programación de tareas en Linux

Si llevas al menos un par de años administrando servidores Linux o desplegando aplicaciones backend, seguro que la sintaxis de crontab se te quedó grabada a fuego. Los famosos cinco asteriscos —* * * * *—, seguidos de un comando de shell o la ruta a un script, se convirtieron en el lenguaje universal para programar tareas en segundo plano ya a finales de los años setenta del siglo pasado, cuando Ken Thompson creó la primera implementación de cron para Unix Version 7.

Durante cuatro décadas seguidas este mecanismo cumplió honestamente con su labor: lanzaba la rotación de logs, generaba volcados nocturnos de bases de datos, enviaba resúmenes por correo electrónico y limpiaba directorios temporales. Pero quitémonos por un segundo las gafas de la nostalgia y miremos con frialdad cómo funciona el cron clásico en la infraestructura cloud moderna con decenas de microservicios, almacenamientos distribuidos y contenedores.

El panorama resulta, por decirlo suavemente, desalentador. En las distribuciones Linux basadas en el sistema de inicio systemd (Ubuntu, Debian, RHEL, CentOS, Rocky Linux, Fedora, Arch Linux, openSUSE) existe desde hace más de diez años una alternativa nativa completa: los temporizadores de systemd (systemd timers). Pero por pura inercia, cientos de equipos siguen tropezando con las mismas piedras de crontab.

El autor del canal «Linux | Network | DevOps» preparó un análisis educativo detallado del mecanismo, apoyándose en el manual oficial de unidades systemd.timer y en la especificación de formatos temporales systemd.time. Ha llegado el momento de diseccionar este subsistema hasta los cimientos y entender por qué el entorno de producción moderno merece algo mejor que líneas arcaicas en /etc/crontab.

Por qué cuatro décadas de cron acabaron en un callejón sin salida arquitectónico

Diseccionemos un incidente real con el que se ha topado todo ingeniero de guardia. Imagina: en el servidor está configurado un volcado nocturno de la base de datos PostgreSQL a las 03:00. A las tres de la madrugada el demonio cron lanza el comando. Pero justo en ese minuto el almacenamiento en red NFS se estaba remontando temporalmente, o el servicio de base de datos se estaba reiniciando tras una actualización programada de paquetes.

¿Qué ocurre en el mundo del cron clásico?

  1. Fallo silencioso y logs perdidos: el script falla con un error en stderr. ¿Adónde va esa salida? Por defecto cron intenta enviar un correo local mediante la utilidad sendmail o mailx al usuario root. Pero en los servidores modernos el servidor de correo local (MTA) ni siquiera está instalado, o los correos se acumulan durante años en /var/mail/root, que nadie abre jamás. Como resultado, el backup no se creó y el equipo se entera dos semanas después, cuando la base cae y no hay nada que restaurar.
  2. Ceguera ante reinicios y ventanas de mantenimiento: si el servidor físico o la máquina virtual estaban reiniciándose exactamente a las 03:00, cron simplemente ignora que el evento debía ocurrir. ¿Son las 03:05? El tiempo pasó, el tren se fue y hasta la noche siguiente no habrá backup.
  3. Ausencia de gestión de recursos: una tarea lanzada desde cron nace como un proceso hijo cualquiera en el espacio común de usuarios. Si en el script se produce una fuga de memoria o un bucle infinito, el proceso devorará el 100% de la CPU y matará la aplicación en producción mediante el servicio vecino Out-Of-Memory Killer.
  4. Imposibilidad de declarar dependencias: en crontab no se puede decir de forma declarativa: «No lances el script hasta que la red esté arriba, el disco esté montado y la base responda al ping». Los ingenieros tienen que apilar apaños en bash con bucles infinitos de sleep y comprobaciones de puertos de red.

En el paradigma de systemd, todos estos problemas están resueltos a nivel arquitectónico fundamental.

Arquitectura de unidades emparejadas: separación estricta entre horario y proceso

La principal diferencia conceptual entre systemd y cron es la separación estricta de responsabilidades.

Esquema infográfico de la separación arquitectónica de tareas en systemd en archivos independientes emparejados .service y .timer.

En cron, el horario de ejecución y el propio cuerpo del comando ejecutable se comprimen en una sola línea ilegible. En systemd, una tarea periódica siempre se divide en dos archivos de unidad independientes:

  • Unidad de servicio (.service): responde a la pregunta QUÉ HACER. Aquí se describe el proceso de trabajo en sí: binario ejecutable, script, directorio de trabajo, usuario del sistema, variables de entorno, límites de memoria, permisos de acceso al sistema de archivos y reglas de comportamiento ante fallos;
  • Unidad temporizador (.timer): responde a la pregunta CUÁNDO Y BAJO QUÉ CONDICIONES EJECUTAR. Aquí se definen los intervalos temporales, la vinculación al reloj o a eventos de arranque del sistema operativo, así como las reglas de compensación de ejecuciones perdidas.

Por defecto, el temporizador busca un servicio con el mismo nombre: si la unidad se llama pg-backup.timer, systemd activará automáticamente el servicio pg-backup.service en el mismo directorio.

Veamos cómo luce una unidad de servicio fiable para una tarea puntual. Fíjate en el tipo Type=oneshot:

# /etc/systemd/system/pg-backup.service
[Unit]
Description=Copia de seguridad de PostgreSQL en archivo local
# Dependencias declarativas: esperamos disponibilidad de red y del servicio local de SGBD
After=network-online.target postgresql.service
Wants=network-online.target postgresql.service

[Service]
Type=oneshot
User=postgres
Group=postgres
WorkingDirectory=/var/lib/postgresql
ExecStart=/usr/local/bin/backup-database.sh

# Registro: toda la salida estándar y errores se envían automáticamente a journald
StandardOutput=journal
StandardError=journal

# Límites estrictos de cgroups v2: protegemos los servicios vecinos
MemoryMax=2G
CPUQuota=50%

Y ahora creamos el temporizador emparejado que gestionará el horario de este servicio:

# /etc/systemd/system/pg-backup.timer
[Unit]
Description=Temporizador de copia de seguridad nocturna de la base de datos

[Timer]
# Horario de calendario: cada noche exactamente a las 03:00
OnCalendar=*-*-* 03:00:00

# La magia principal: recuperar la ejecución si el servidor estaba apagado a las 03:00
Persistent=true

# Jitter aleatorio: repartimos el pico de carga en disco en un margen de 15 minutos
RandomizedDelaySec=15m

[Install]
# El temporizador se activa al arrancar el target base del sistema para temporizadores
WantedBy=timers.target

Para que el horario cobre vida, basta con ejecutar el comando estándar de inicialización:

# Recargamos la configuración de systemd y activamos el temporizador
systemctl daemon-reload
systemctl enable --now pg-backup.timer

Monótonos frente a calendario: cómo se llevan los temporizadores con el kernel y el reloj

En el cron clásico, cualquier horario está atado rígidamente al reloj astronómico del sistema. Si en el servidor se desincroniza la hora, o si el administrador del sistema atrasa manualmente una hora el reloj, cron puede dispararse dos veces o saltarse una ejecución.

En systemd existe una clara división de los temporizadores en dos clases fundamentalmente distintas:

1. Temporizadores monótonos (Monotonic Timers)

No están vinculados a la hora de pared, sino al reloj hardware monótono del kernel Linux (CLOCK_MONOTONIC). Este reloj avanza estrictamente hacia delante desde el arranque del procesador; es imposible atrasarlo ni alterarlo con un paquete NTP erróneo.

Las directivas de los temporizadores monótonos son ideales para tareas periódicas por intervalos:

  • OnBootSec=15min: lanzar el servicio exactamente 15 minutos después del arranque del kernel del sistema operativo;
  • OnUnitActiveSec=1h: repetir la ejecución cada hora respecto al momento de la activación exitosa anterior del servicio;
  • OnUnitInactiveSec=30min: mantener una pausa de 30 minutos tras finalizar la ejecución del proceso anterior.

Nota la diferencia colosal: si tu pesada tarea de limpieza de caché tardó 40 minutos en ejecutarse, la directiva OnUnitInactiveSec=30min garantiza que la siguiente ejecución ocurrirá exactamente 30 minutos después de terminar la anterior, evitando el peligroso solapamiento de procesos sin necesidad de archivos lock externos.

2. Temporizadores de calendario (Realtime / Calendar Timers)

Funcionan según la hora de pared (CLOCK_REALTIME) y se configuran mediante la directiva OnCalendar.

La sintaxis de la especificación systemd.time es un orden de magnitud más expresiva y humana que las cinco columnas de crontab:

  • OnCalendar=hourly — cada hora en el minuto cero;
  • OnCalendar=daily — cada medianoche a las 00:00:00;
  • OnCalendar=Mon..Fri *-*-* 04:30:00 — solo días laborables de lunes a viernes a las cuatro y media de la mañana;
  • OnCalendar=*-*-01 02:00:00 — el día uno de cada mes a las dos de la madrugada;
  • OnCalendar=*-*-* *:00/15:00 — cada quince minutos de cualquier hora.

Fíjate: los asteriscos van separados por guiones y dos puntos. Equivocarse en esta sintaxis es diez veces más difícil que en la sucesión de espacios entre cifras de cron.

Anatomía de Persistent=true: cómo recuperar backups nocturnos tras caídas

Uno de los problemas más destructivos de cron siempre fue su amnesia total ante los reinicios. Si una máquina virtual con un entorno dev o stage se apaga por la noche para ahorrar recursos, las tareas matutinas de backup simplemente no se ejecutan nunca.

En systemd este problema lo resuelve con elegancia una única directiva:

Persistent=true

Veamos qué ocurre bajo el capó al activar este flag:

  1. En cada ejecución exitosa del servicio objetivo, el gestor systemd toma la marca temporal actual y la escribe de forma atómica en un archivo sello especial en disco en la ruta /var/lib/systemd/timers/stamp-<nombre-de-unidad>.timer.
  2. Si a las 03:00 de la madrugada el servidor estaba apagado, en un reinicio de emergencia o el hipervisor estaba migrando el host, el archivo sello conserva la hora del arranque de ayer.
  3. En cuanto el servidor arranca (por ejemplo, a las 08:30 de la mañana), systemd lee todos los sellos del disco al inicializar el target timers.target y los compara con el calendario.
  4. Al ver que la programación de las 03:00 se perdió, systemd activa de inmediato el servicio vencido pg-backup.service, sin esperar a la noche siguiente.

Este mecanismo garantiza que los procedimientos de mantenimiento críticos se ejecuten al menos una vez en el periodo planificado, incluso si el servidor se reinicia con regularidad.

Inspección transparente: systemd-analyze y diagnóstico sin calculadoras externas

¿Cuántas veces antes de guardar un archivo crontab has entrado en servicios online como crontab.guru para comprobar si pusiste bien los asteriscos y si el script no iba a lanzarse cada dos segundos en lugar de a las dos de la madrugada?

Systemd lleva integrado un conjunto de herramientas de diagnóstico profesional. Cualquier expresión de calendario puede comprobarse directamente en la terminal con la utilidad systemd-analyze calendar:

# Comprobamos una expresión de calendario compleja antes de añadirla a la configuración
systemd-analyze calendar "Mon..Fri *-*-* 03:00:00"

El comando devuelve un informe exhaustivo:

Normalized form: Mon..Fri *-*-* 03:00:00
   Next elapse: Fri 2026-11-06 03:00:00 MSK
      (in UTC): Fri 2026-11-06 00:00:00 UTC
      From now: 13h left

La utilidad muestra la forma canónica normalizada, recalcula la hora a UTC e indica cuántas horas y minutos faltan para el próximo disparo.

Y para ver el panorama completo de todas las tareas programadas en todo el servidor, basta con ejecutar:

systemctl list-timers --all

El comando imprime una tabla cristalina con las columnas:

  • NEXT: fecha y hora exactas de la próxima ejecución;
  • LEFT: tiempo restante hasta el arranque (por ejemplo, 2h 45min left);
  • LAST: cuándo se ejecutó la tarea por última vez;
  • PASSED: cuánto tiempo ha pasado desde la ejecución anterior;
  • UNIT: nombre de la unidad temporizador activa;
  • ACTIVATES: nombre del servicio que será invocado.

Nada de magia ni archivos crontab de usuario ocultos en /var/spool/cron/crontabs: toda la infraestructura de horarios se ve en la palma de la mano en una única interfaz.

Aislamiento de recursos con cgroups v2 y tareas puntuales mediante systemd-run

Otra baza colosal de systemd es el control estricto de los recursos hardware mediante la segunda versión de los grupos de control del kernel (cgroups v2).

En el cron clásico, un script lanzado se ejecuta sin límite alguno. Si un junior escribió un script de exportación de informes olvidando limitar la selección en la consulta SQL, el proceso reservará 30 GB de memoria RAM y tumbará el clúster de producción que corre al lado.

En una unidad de servicio de systemd podemos añadir directivas estrictas de aislamiento:

[Service]
# Limitamos el consumo de memoria: techo estricto de 2 GB
MemoryMax=2G
# Frenamos la asignación de memoria al superar el umbral de 1.5 GB
MemoryHigh=1.5G
# Limitamos el tiempo de CPU: no más de un núcleo (100%)
CPUQuota=100%
# Prioridad de E/S: la tarea de backup no debe colgar el disco
IOWeight=100

Si el proceso intenta superar el límite MemoryMax, el kernel matará con precisión únicamente al proceso hijo del script, manteniendo con vida el sistema principal. Y todo el curso de la ejecución y los errores quedarán ordenadamente guardados en el diario del sistema:

# Leemos el log detallado de ejecución de una tarea concreta en las últimas 24 horas
journalctl -u pg-backup.service --since "yesterday"

¿Y qué hacer si necesitas lanzar una tarea temporal puntual sin crear archivos manualmente en disco? Para ello existe el magnífico comando systemd-run:

# Lanzar un script pesado dentro de 20 minutos en un contexto aislado con límite de memoria
systemd-run --on-active=20m --property=MemoryMax=1G /usr/local/bin/heavy-maintenance.sh

La utilidad generará por sí misma una unidad transitoria temporal en memoria RAM, ejecutará el comando y eliminará la definición al terminar.

Lista de verificación práctica de migración y compromisos en producción

Pasar de crontab a systemd timers no es solo un cambio de herramienta, sino un salto cualitativo en la madurez de la infraestructura de servidores. Fijemos los pasos principales de la transición:

  1. Inventario de tareas antiguas: revisa el contenido de /etc/crontab, los directorios /etc/cron.d/ y los horarios de usuario crontab -l.
  2. Creación de plantillas: crea las unidades de servicio base en /etc/systemd/system/, indicando explícitamente los directorios de trabajo, los usuarios del sistema y las dependencias declarativas (After=network-online.target).
  3. Configuración de calendario y jitter: para tareas que corren en varios servidores en paralelo, utiliza obligatoriamente la directiva RandomizedDelaySec=10m. Esto evitará el bombardeo simultáneo contra APIs externas o cabinas de discos (el llamado thundering herd problem).
  4. Validación mediante systemd-analyze: antes de activar, pasa cada horario por el analizador de calendario.

Por supuesto, los systemd timers tienen un precio: en lugar de editar un único archivo de texto en nano, tienes que crear dos archivos de unidad separados. Pero para producción industrial, esta ligera verbosidad se compensa con creces con la transparencia, la fiabilidad del registro y la garantía de que tus tareas nocturnas realmente se ejecutarán como corresponde.

Quiero un análisis detalladoLos votos ayudan a elegir qué analizar a fondo. Este material tiene 0 votos.
Fuentes · 3