Ejecutando un cron cada 30 segundos

Ok, entonces tengo un cron que necesito ejecutar cada 30 segundos.

Esto es lo que tengo:

*/30 * * * * /bin/bash -l -c 'cd /srv/last_song/releases/20120308133159 && script/rails runner -e production '\''Song.insert_latest'\'''

Se ejecuta, pero ¿se está ejecutando cada 30 minutos o 30 segundos?

Además, he estado leyendo que cron podría no ser la mejor herramienta para usar si lo ejecuto con tanta frecuencia. ¿Hay otra herramienta mejor que pueda usar o instalar en Ubuntu 11.04 que será una mejor opción? ¿Hay alguna manera de arreglar el cron anterior?

Tienes */30el especificador de minutos , eso significa cada minuto pero con un paso de 30 (en otras palabras, cada media hora). Como cronno se reduce a resoluciones de menos de un minuto, deberá buscar otra forma.

Una posibilidad, aunque es un poco un error ^(a) , es tener dos trabajos, uno compensado por 30 segundos:

# Need these to run on 30-sec boundaries, keep commands in sync.
* * * * *              /path/to/executable param1 param2
* * * * * ( sleep 30 ; /path/to/executable param1 param2 )

Verá que agregué comentarios y los formateé para garantizar que sea fácil mantenerlos sincronizados.

Ambos crontrabajos realmente se ejecutan cada minuto, pero el último esperará medio minuto antes de ejecutar la "carne" del trabajo /path/to/executable.

Para otras cronopciones (no basadas), vea las otras respuestas aquí, particularmente las que mencionan fcrony systemd. Probablemente sean preferibles suponiendo que su sistema tenga la capacidad de usarlos (como instalar fcrono tener una distribución systemddentro).

Si no desea usar la solución kludgy, puede usar una solución basada en bucles con una pequeña modificación. Todavía tendrá que administrar mantener su proceso ejecutándose de alguna forma, pero, una vez que esté ordenado, el siguiente script debería funcionar:

#!/bin/env bash

# Debug code to start on minute boundary and to
# gradually increase maximum payload duration to
# see what happens when the payload exceeds 30 seconds.

((maxtime = 20))
while [[ "$(date +%S)" != "00" ]]; do true; done

while true; do
    # Start a background timer BEFORE the payload runs.

    sleep 30 &

    # Execute the payload, some random duration up to the limit.
    # Extra blank line if excess payload.

    ((delay = RANDOM % maxtime + 1))
    ((maxtime += 1))
    echo "$(date) Sleeping for ${delay} seconds (max ${maxtime})."
    [[ ${delay} -gt 30 ]] && echo
    sleep ${delay}

    # Wait for timer to finish before next cycle.

    wait
done

El truco consiste en utilizar un sleep 30pero para iniciarlo en segundo plano antes de que se ejecute su carga útil. Luego, una vez finalizada la carga útil, solo espere sleepa que termine el fondo .

Si la carga útil tarda nsegundos (donde n <= 30), la espera después de la carga útil será 30 - nsegundos. Si demora más de 30 segundos, el siguiente ciclo se retrasará hasta que finalice la carga útil, pero ya no.

Verá que tengo un código de depuración para comenzar en un límite de un minuto para hacer que la salida sea inicialmente más fácil de seguir. También aumento gradualmente el tiempo máximo de carga útil para que eventualmente vea que la carga útil excede el tiempo de ciclo de 30 segundos (se genera una línea en blanco adicional para que el efecto sea obvio).

Sigue una ejecución de muestra (donde los ciclos normalmente comienzan 30 segundos después del ciclo anterior):

Tue May 26 20:56:00 AWST 2020 Sleeping for 9 seconds (max 21).
Tue May 26 20:56:30 AWST 2020 Sleeping for 19 seconds (max 22).
Tue May 26 20:57:00 AWST 2020 Sleeping for 9 seconds (max 23).
Tue May 26 20:57:30 AWST 2020 Sleeping for 7 seconds (max 24).
Tue May 26 20:58:00 AWST 2020 Sleeping for 2 seconds (max 25).
Tue May 26 20:58:30 AWST 2020 Sleeping for 8 seconds (max 26).
Tue May 26 20:59:00 AWST 2020 Sleeping for 20 seconds (max 27).
Tue May 26 20:59:30 AWST 2020 Sleeping for 25 seconds (max 28).
Tue May 26 21:00:00 AWST 2020 Sleeping for 5 seconds (max 29).
Tue May 26 21:00:30 AWST 2020 Sleeping for 6 seconds (max 30).
Tue May 26 21:01:00 AWST 2020 Sleeping for 27 seconds (max 31).
Tue May 26 21:01:30 AWST 2020 Sleeping for 25 seconds (max 32).
Tue May 26 21:02:00 AWST 2020 Sleeping for 15 seconds (max 33).
Tue May 26 21:02:30 AWST 2020 Sleeping for 10 seconds (max 34).
Tue May 26 21:03:00 AWST 2020 Sleeping for 5 seconds (max 35).
Tue May 26 21:03:30 AWST 2020 Sleeping for 35 seconds (max 36).

Tue May 26 21:04:05 AWST 2020 Sleeping for 2 seconds (max 37).
Tue May 26 21:04:35 AWST 2020 Sleeping for 20 seconds (max 38).
Tue May 26 21:05:05 AWST 2020 Sleeping for 22 seconds (max 39).
Tue May 26 21:05:35 AWST 2020 Sleeping for 18 seconds (max 40).
Tue May 26 21:06:05 AWST 2020 Sleeping for 33 seconds (max 41).

Tue May 26 21:06:38 AWST 2020 Sleeping for 31 seconds (max 42).

Tue May 26 21:07:09 AWST 2020 Sleeping for 6 seconds (max 43).

Si desea evitar la solución kludgy, probablemente sea mejor. Aún necesitará un crontrabajo (o equivalente) para detectar periódicamente si este script se está ejecutando y, si no, iniciarlo. Pero el guión mismo maneja el tiempo.

^(a) Algunos de mis compañeros de trabajo dirían que los kludges son mi especialidad :-)

No puedes Cron tiene una granularidad de 60 segundos.

* * * * * cd /srv/last_song/releases/20120308133159 && script/rails runner -e production '\''Song.insert_latest'\''
* * * * * sleep 30 && cd /srv/last_song/releases/20120308133159 && script/rails runner -e production '\''Song.insert_latest'\''

La granularidad de Cron está en minutos y no fue diseñada para despertarse cada xsegundo para ejecutar algo. Ejecute su tarea repetitiva dentro de un bucle y debería hacer lo que necesita:

#!/bin/env bash
while [ true ]; do
 sleep 30
 # do what you need to here
done

Si está ejecutando un sistema operativo Linux reciente con SystemD, puede usar la unidad de temporizador SystemD para ejecutar su secuencia de comandos en cualquier nivel de granularidad que desee (teóricamente hasta nanosegundos) y, si lo desea, reglas de inicio mucho más flexibles de lo que Cron alguna vez permitió . No se sleeprequieren errores

Se necesita un poco más de configuración que una sola línea en un archivo cron, pero si necesita algo mejor que "Cada minuto", vale la pena el esfuerzo.

El modelo de temporizador SystemD es básicamente esto: los temporizadores son unidades que inician unidades de servicio cuando transcurre un temporizador .

Entonces, para cada script / comando que desee programar, debe tener una unidad de servicio y luego una unidad de temporizador adicional. Una sola unidad de temporizador puede incluir múltiples horarios, por lo que normalmente no necesitaría más de un temporizador y un servicio.

Aquí hay un ejemplo simple que registra "Hello World" cada 10 segundos:

/etc/systemd/system/helloworld.service:

[Unit]
Description=Say Hello
[Service]
ExecStart=/usr/bin/logger -i Hello World

/etc/systemd/system/helloworld.timer:

[Unit]
Description=Say Hello every 10 seconds
[Timer]
OnBootSec=10
OnUnitActiveSec=10
AccuracySec=1ms
[Install]
WantedBy=timers.target

Después de configurar estas unidades (en /etc/systemd/system, como se describió anteriormente, para una configuración de todo el sistema o ~/.config/systemd/userpara una configuración específica del usuario), debe habilitar el temporizador (no el servicio) ejecutando systemctl enable --now helloworld.timer(el --nowindicador también inicia el temporizador inmediatamente, de lo contrario, solo comenzará después del siguiente arranque o inicio de sesión del usuario).

Los [Timer]campos de sección utilizados aquí son los siguientes:

• OnBootSec - inicie el servicio tantos segundos después de cada arranque.
• OnUnitActiveSec- inicie el servicio varios segundos después de la última vez que se inició. Esto es lo que hace que el temporizador se repita y se comporte como un trabajo cron.
• AccuracySec- Establece la precisión del temporizador. Los temporizadores son tan precisos como este campo establece, y el valor predeterminado es 1 minuto (emula cron). La razón principal para no exigir la mejor precisión es mejorar el consumo de energía: si SystemD puede programar la próxima ejecución para que coincida con otros eventos, debe reactivar la CPU con menos frecuencia. El 1msejemplo anterior no es ideal: generalmente establezco la precisión en 1(1 segundo) en mis trabajos programados de menos de un minuto, pero eso significaría que si mira el registro que muestra los mensajes de "Hola Mundo", verá que a menudo es tarde por 1 segundo. Si está de acuerdo con eso, sugiero configurar la precisión en 1 segundo o más.

Como habrás notado, este temporizador no imita a Cron tan bien, en el sentido de que el comando no comienza al comienzo de cada período de reloj de pared (es decir, no comienza en el décimo segundo del reloj, luego el 20 y así sucesivamente). En cambio, solo sucede cuando el temporizador transcurre. Si el sistema se inició a las 12:05:37, la próxima vez que se ejecute el comando será a las 12:05:47, luego a las 12:05:57, etc. Si está interesado en la precisión real del reloj de pared, puede desee reemplazar las OnBootSecy OnUnitActiveSeclos campos y en su lugar establecer una OnCalendarregla con el programa que desea (que por lo que yo entiendo, no puede ser más rápido que 1 segundo, usando el formato del calendario). El ejemplo anterior también se puede escribir como:

OnCalendar=*-*-* *:*:00,10,20,30,40,50

Última nota: como probablemente haya adivinado, la helloworld.timerunidad inicia la helloworld.serviceunidad porque tienen el mismo nombre (menos el sufijo del tipo de unidad). Este es el valor predeterminado, pero puede anularlo configurando el Unitcampo para la [Timer]sección.

Se pueden encontrar más detalles sangrientos en:

• La página Wiki de Arch Linux sobre temporizadores SystemD que ofrece una muy buena visión general del tema, con ejemplos.
• man systemd.timer
• man systemd.time
• man systemd.service
• man system.exec

No necesita dos entradas cron, puede ponerlas en una con:

* * * * * /bin/bash -l -c "/path/to/executable; sleep 30 ; /path/to/executable"

entonces en tu caso:

* * * * * /bin/bash -l -c "cd /srv/last_song/releases/20120308133159 && script/rails runner -e production '\''Song.insert_latest'\'' ; sleep 30 ; cd /srv/last_song/releases/20120308133159 && script/rails runner -e production '\''Song.insert_latest'\''"

Puedes ver mi respuesta a esta pregunta similar

Básicamente, he incluido un script de bash llamado "runEvery.sh" que puede ejecutar con cron cada 1 minuto y pasar como argumentos el comando real que desea ejecutar y la frecuencia en segundos en que desea ejecutarlo.

algo como esto

* * * * * ~/bin/runEvery.sh 5 myScript.sh

Usar reloj:

$ watch --interval .30 script_to_run_every_30_sec.sh

El trabajo Cron no se puede utilizar para programar un trabajo en intervalos de segundos. es decir, no puede programar un trabajo cron para que se ejecute cada 5 segundos. La alternativa es escribir un script de shell que use un sleep 5comando en él.

Cree un script de shell cada 5- segundos.sh usando bash while loop como se muestra a continuación.

$ cat every-5-seconds.sh
#!/bin/bash
while true
do
 /home/ramesh/backup.sh
 sleep 5
done

Ahora, ejecute este script de shell en segundo plano usando nohupcomo se muestra a continuación. Esto seguirá ejecutando el script incluso después de cerrar sesión en su sesión. Esto ejecutará su script de shell backup.sh cada 5 segundos.

$ nohup ./every-5-seconds.sh &

Use fcron ( http://fcron.free.fr/ ): le brinda granularidad en segundos y mucho mejor y más funciones que cron (vixie-cron) y también estable. Solía ​​hacer cosas estúpidas, como tener alrededor de 60 scripts PHP ejecutados en una máquina en configuraciones muy estúpidas, ¡y todavía hizo su trabajo!

en dir /etc/cron.d/

nuevo crea un archivo excute_per_30s

* * * * * yourusername  /bin/date >> /home/yourusername/temp/date.txt
* * * * * yourusername sleep 30; /bin/date >> /home/yourusername/temp/date.txt

ejecutará cron cada 30 segundos

Actualmente estoy usando el siguiente método. Funciona sin problemas.

* * * * * /bin/bash -c ' for i in {1..X}; do YOUR_COMMANDS ; sleep Y ; done '

Si desea ejecutar cada N segundos y luego X habrá 60 / N y Y habrá N .

Gracias.

El trabajo de Crontab se puede usar para programar un trabajo en minutos / horas / días, pero no en segundos. La alternativa :

Cree un script para ejecutar cada 30 segundos:

#!/bin/bash
# 30sec.sh

for COUNT in `seq 29` ; do
  cp /application/tmp/* /home/test
  sleep 30
done

Use crontab -ey un crontab para ejecutar este script:

* * * * * /home/test/30sec.sh > /dev/null

Puede ejecutar ese script como servicio, reiniciar cada 30 segundos

Registrar un servicio

sudo vim /etc/systemd/system/YOUR_SERVICE_NAME.service

Pega el comando a continuación

Description=GIVE_YOUR_SERVICE_A_DESCRIPTION

Wants=network.target
After=syslog.target network-online.target

[Service]
Type=simple
ExecStart=YOUR_COMMAND_HERE
Restart=always
RestartSec=10
KillMode=process

[Install]
WantedBy=multi-user.target

Servicios de recarga

sudo systemctl daemon-reload

Habilitar el servicio

sudo systemctl enable YOUR_SERVICE_NAME

Inicia el servicio

sudo systemctl start YOUR_SERVICE_NAME

Verifique el estado de su servicio

systemctl status YOUR_SERVICE_NAME

Gracias por todas las buenas respuestas. Para simplificar, me gustó la solución mixta, con el control en crontab y la división de tiempo en el script. Entonces, esto es lo que hice para ejecutar un script cada 20 segundos (tres veces por minuto). Línea Crontab:

 * * * * 1-6 ./a/b/checkAgendaScript >> /home/a/b/cronlogs/checkAgenda.log

Guión:

cd /home/a/b/checkAgenda

java -jar checkAgenda.jar
sleep 20
java -jar checkAgenda.jar 
sleep 20
java -jar checkAgenda.jar 

escribir un script de shell crear archivo .sh

nano cada 30 segundos.sh

y escribir guion

#!/bin/bash
For  (( i=1; i <= 2; i++ ))
do
    write Command here
    sleep 30
done

luego configure cron para este script crontab -e

(* * * * * /home/username/every30second.sh)

este archivo cron call .sh cada 1 minuto y en el comando del archivo .sh se ejecuta 2 veces en 1 minuto

si desea ejecutar el script durante 5 segundos, reemplace 30 por 5 y cambie el bucle de esta manera: For (( i=1; i <= 12; i++ ))

cuando selecciona por cualquier segundo, calcule 60 / su segundo y escriba en el bucle For

Acabo de hacer una tarea similar y utilizo el siguiente enfoque:

nohup watch -n30 "kill -3 NODE_PID" &

Necesitaba tener un kill -3 periódico (para obtener el seguimiento de la pila de un programa) cada 30 segundos durante varias horas.

nohup ... & 

Esto está aquí para asegurarse de que no pierdo la ejecución de watch si pierdo el shell (problema de red, bloqueo de Windows, etc.)

Eche un vistazo a frecuente-cron : es antiguo pero muy estable y puede reducirlo a microsegundos. En este momento, lo único que diría contra esto es que todavía estoy tratando de resolver cómo instalarlo fuera de init.d pero como un servicio systemd nativo, pero ciertamente hasta Ubuntu 18 se está ejecutando solo bien todavía usando init.d (la distancia puede variar en las últimas versiones). Tiene la ventaja adicional (?) De garantizar que no generará otra instancia del script PHP a menos que se haya completado una anterior, lo que reduce los posibles problemas de pérdida de memoria.

Ejecutar en un ciclo de shell, ejemplo:

#!/bin/sh    
counter=1
while true ; do
 echo $counter
 counter=$((counter+1))
 if [[ "$counter" -eq 60 ]]; then
  counter=0
 fi
 wget -q http://localhost/tool/heartbeat/ -O - > /dev/null 2>&1 &
 sleep 1
done