Exécution d'un cron toutes les 30 secondes

Ok, j'ai donc un cron que je dois exécuter toutes les 30 secondes.

Voici ce que j'ai:

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

Il fonctionne, mais est-ce que cela fonctionne toutes les 30 minutes ou 30 secondes?

De plus, j'ai lu que cron pourrait ne pas être le meilleur outil à utiliser si je l'exécute aussi souvent. Y a-t-il un autre meilleur outil que je peux utiliser ou installer sur Ubuntu 11.04 qui sera une meilleure option? Existe-t-il un moyen de corriger le cron ci-dessus?

Vous avez */30dans le spécificateur de minutes - cela signifie chaque minute mais avec un pas de 30 (en d'autres termes, toutes les demi-heures). Étant donné que croncela ne se résume pas à des résolutions de moins d'une minute, vous devrez trouver un autre moyen.

Une possibilité, bien que ce soit un peu compliqué ^(a) , est d'avoir deux tâches, une décalée de 30 secondes:

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

Vous verrez que j'ai ajouté des commentaires et formaté pour vous assurer qu'il est facile de les synchroniser.

Les deux crontravaux sont exécutés en fait chaque minute mais celui- ci on va attendre une demi - minute avant d' exécuter la « viande » du travail, /path/to/executable.

Pour d'autres cronoptions (non basées), voir les autres réponses ici, en particulier celles mentionnant fcronet systemd. Celles-ci sont probablement préférables en supposant que votre système a la capacité de les utiliser (comme installer fcronou avoir une distribution avec systemd).

Si vous ne souhaitez pas utiliser la solution kludgy, vous pouvez utiliser une solution basée sur une boucle avec une petite modification. Vous devrez toujours gérer le maintien de votre processus sous une forme ou une autre, mais une fois trié, le script suivant devrait fonctionner:

#!/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

L'astuce consiste à utiliser un sleep 30mais à le démarrer en arrière - plan avant l'exécution de votre charge utile. Ensuite, une fois la charge utile terminée, attendez que l'arrière-plan sleepse termine.

Si la charge utile prend nquelques secondes (où n <= 30), l'attente après la charge utile sera alors de 30 - nquelques secondes. Si cela prend plus de 30 secondes, le cycle suivant sera retardé jusqu'à ce que la charge utile soit terminée, mais plus.

Vous verrez que j'ai du code de débogage là-dedans pour commencer sur une limite d'une minute pour rendre la sortie initialement plus facile à suivre. J'augmente également progressivement la durée maximale de la charge utile afin que vous finissiez par voir la charge utile dépasser le temps de cycle de 30 secondes (une ligne vierge supplémentaire est sortie, l'effet est donc évident).

Un cycle d'échantillonnage suit (où les cycles commencent normalement 30 secondes après le cycle précédent):

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 vous voulez éviter la solution kludgy, c'est probablement mieux. Vous aurez toujours besoin d'un crontravail (ou équivalent) pour détecter périodiquement si ce script est en cours d'exécution et, sinon, le démarrer. Mais le script lui-même gère alors le timing.

^(a) Certains de mes collègues diraient que les gourmandises sont ma spécialité :-)

Tu ne peux pas. Cron a une granularité de 60 secondes.

* * * * * 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 granularité de Cron est en quelques minutes et n'a pas été conçue pour se réveiller toutes les xsecondes pour exécuter quelque chose. Exécutez votre tâche répétitive dans une boucle et elle devrait faire ce dont vous avez besoin:

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

Si vous utilisez un système d'exploitation Linux récent avec SystemD, vous pouvez utiliser l'unité SystemD Timer pour exécuter votre script à n'importe quel niveau de granularité que vous souhaitez (théoriquement jusqu'à nanosecondes), et - si vous le souhaitez - des règles de lancement beaucoup plus flexibles que Cron n'a jamais autorisé . Aucun sleepkludges requis

Il faut un peu plus de temps pour configurer qu'une seule ligne dans un fichier cron, mais si vous avez besoin de quelque chose de mieux que "Chaque minute", cela vaut bien l'effort.

Le modèle de temporisation SystemD est essentiellement le suivant: les temporisateurs sont des unités qui démarrent des unités de service lorsqu'une temporisation s'est écoulée .

Donc, pour chaque script / commande que vous souhaitez planifier, vous devez avoir une unité de service, puis une unité de temporisation supplémentaire. Une seule unité de minuterie peut inclure plusieurs planifications, vous n'avez donc normalement pas besoin de plus d'une minuterie et d'un service.

Voici un exemple simple qui enregistre "Hello World" toutes les 10 secondes:

/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

Après avoir configuré ces unités (dans /etc/systemd/system, comme décrit ci-dessus, pour un paramètre à l'échelle du système ou ~/.config/systemd/userpour une configuration spécifique à l'utilisateur), vous devez activer la minuterie (mais pas le service) en exécutant systemctl enable --now helloworld.timer(l' --nowindicateur démarre également la minuterie immédiatement, sinon, il ne démarrera qu'après le prochain démarrage ou la connexion de l'utilisateur).

Les [Timer]champs de section utilisés ici sont les suivants:

• OnBootSec - démarrez le service autant de secondes après chaque démarrage.
• OnUnitActiveSec- démarrez le service autant de secondes après le dernier démarrage du service. C'est ce qui fait que la minuterie se répète et se comporte comme une tâche cron.
• AccuracySec- définit la précision de la minuterie. Les minuteries ne sont aussi précises que ce champ définit, et la valeur par défaut est 1 minute (émule cron). La principale raison pour ne pas exiger la meilleure précision est d'améliorer la consommation d'énergie - si SystemD peut planifier la prochaine exécution pour coïncider avec d'autres événements, il doit réveiller le processeur moins souvent. L' 1msexemple ci-dessus n'est pas idéal - je règle généralement la précision sur 1(1 seconde) dans mes tâches planifiées d'une minute, mais cela signifierait que si vous regardez le journal affichant les messages "Hello World", vous verriez que il est souvent en retard d'une seconde. Si vous êtes d'accord avec cela, je suggère de définir la précision sur 1 seconde ou plus.

Comme vous l'avez peut-être remarqué, cette minuterie n'imite pas très bien Cron - dans le sens où la commande ne démarre pas au début de chaque période d'horloge murale (c'est-à-dire qu'elle ne démarre pas à la 10e seconde de l'horloge, puis le 20 et ainsi de suite). Au lieu de cela, cela se produit uniquement lorsque la minuterie s'écoule. Si le système démarre à 12:05:37, la prochaine exécution de la commande sera alors à 12:05:47, puis à 12:05:57, etc. Si vous êtes intéressé par la précision réelle de l'horloge murale, alors vous pouvez pour remplacer les OnBootSecet les OnUnitActiveSecchamps et au lieu définir une OnCalendarrègle avec le calendrier que vous voulez (qui, autant que je sache ne peut pas être plus rapide de 1 seconde, en utilisant le format de calendrier). L'exemple ci-dessus peut également s'écrire:

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

Dernière remarque: comme vous l'avez probablement deviné, l' helloworld.timerunité démarre l' helloworld.serviceunité car elle porte le même nom (moins le suffixe du type d'unité). Il s'agit de la valeur par défaut, mais vous pouvez la remplacer en définissant le Unitchamp de la [Timer]section.

Plus de détails sanglants peuvent être trouvés sur:

• Arch Linux Wiki page sur les temporisateurs SystemD qui donne un très bon aperçu du sujet, avec des exemples.
• man systemd.timer
• man systemd.time
• man systemd.service
• man system.exec

Pas besoin de deux entrées cron, vous pouvez les mettre en une avec:

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

donc dans votre cas:

* * * * * /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'\''"

Vous pouvez consulter ma réponse à cette question similaire

Fondamentalement, j'ai inclus un script bash nommé "runEvery.sh" que vous pouvez exécuter avec cron toutes les 1 minute et passer en arguments la vraie commande que vous souhaitez exécuter et la fréquence en secondes pendant laquelle vous souhaitez l'exécuter.

quelque chose comme ça

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

Utilisez la montre:

$ watch --interval .30 script_to_run_every_30_sec.sh

Le travail Cron ne peut pas être utilisé pour planifier un travail en quelques secondes. c'est-à-dire que vous ne pouvez pas planifier une tâche cron pour qu'elle s'exécute toutes les 5 secondes. L'alternative est d'écrire un script shell qui utilise une sleep 5commande dedans.

Créez un script shell toutes les 5 à 5 secondes à l'aide de la boucle bash while, comme illustré ci-dessous.

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

Maintenant, exécutez ce script shell en arrière-plan en utilisant nohupcomme indiqué ci-dessous. Cela continuera à exécuter le script même après la déconnexion de votre session. Cela exécutera votre script shell backup.sh toutes les 5 secondes.

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

Utilisez fcron ( http://fcron.free.fr/ ) - vous donne une granularité en quelques secondes et bien meilleure et plus riche en fonctionnalités que cron (vixie-cron) et stable aussi. J'avais l'habitude de faire des choses stupides comme avoir environ 60 scripts PHP en cours d'exécution sur une machine dans des paramètres très stupides et il a toujours fait son travail!

en dir /etc/cron.d/

nouveau créer un fichier excute_per_30s

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

exécutera cron toutes les 30 secondes

Actuellement, j'utilise la méthode ci-dessous. Fonctionne sans problème.

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

Si vous voulez exécuter toutes les N secondes alors X aura 60 / N et Y sera N .

Je vous remercie.

Le travail Crontab peut être utilisé pour planifier un travail en minutes / heures / jours, mais pas en quelques secondes. L'alternative :

Créez un script à exécuter toutes les 30 secondes:

#!/bin/bash
# 30sec.sh

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

Utilisez crontab -eet une crontab pour exécuter ce script:

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

Vous pouvez exécuter ce script en tant que service, redémarrer toutes les 30 secondes

Enregistrer un service

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

Collez la commande ci-dessous

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

Services de rechargement

sudo systemctl daemon-reload

Activer le service

sudo systemctl enable YOUR_SERVICE_NAME

Démarrez le service

sudo systemctl start YOUR_SERVICE_NAME

Vérifiez l'état de votre service

systemctl status YOUR_SERVICE_NAME

Merci pour toutes les bonnes réponses. Pour faire simple, j'ai aimé la solution mixte, avec le contrôle sur crontab et la division temporelle sur le script. C'est donc ce que j'ai fait pour exécuter un script toutes les 20 secondes (trois fois par minute). Ligne Crontab:

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

Scénario:

cd /home/a/b/checkAgenda

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

écrire un script shell créer un fichier .sh

nano every30second.sh

et écrire un script

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

puis définissez cron pour ce script crontab -e

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

ce fichier .sh d'appel cron toutes les 1 min et dans la commande de fichier .sh est exécuté 2 fois en 1 min

si vous voulez exécuter le script pendant 5 secondes, remplacez 30 par 5 et changez pour la boucle comme ceci: For (( i=1; i <= 12; i++ ))

lorsque vous sélectionnez une seconde, puis calculez 60 / votre seconde et écrivez dans la boucle For

J'ai juste eu une tâche similaire à faire et à utiliser l'approche suivante:

nohup watch -n30 "kill -3 NODE_PID" &

J'avais besoin d'avoir un kill périodique -3 (pour obtenir la trace de la pile d'un programme) toutes les 30 secondes pendant plusieurs heures.

nohup ... & 

C'est là pour être sûr que je ne perds pas l'exécution de watch si je perds le shell (problème réseau, plantage de windows etc ...)

Jetez un oeil à fréquent-cron - il est ancien mais très stable et vous pouvez descendre à la micro-seconde. À ce stade, la seule chose que je dirais contre, c'est que j'essaie toujours de savoir comment l'installer en dehors d'init.d mais en tant que service systemd natif, mais certainement jusqu'à Ubuntu 18, il ne fonctionne que très bien en utilisant init.d (la distance peut varier sur ces dernières versions). Il a l'avantage supplémentaire (?) De garantir qu'il ne générera pas une autre instance du script PHP à moins qu'une précédente ne soit terminée, ce qui réduit les problèmes potentiels de fuite de mémoire.

Exécuter dans une boucle shell, exemple:

#!/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