Exécution d'un cron toutes les 30 secondes

313

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?

Matt Elhotiby
la source
CommaToast, et que se passe-t-il si votre application Javascript ou Java tombe pour une raison quelconque et se ferme? Comment va-t-il redémarrer? :-)
paxdiablo
12
Ajoutez une petite application NodeJS, lol. Pourquoi pas une petite application c ++? Pendant que nous y sommes, nous pouvons le nommer «cron» et l'exécuter en tant que service.
Andrew
Je viens de trouver cela en regardant les profils d'utilisateurs et j'ai vu que vous étiez en ligne il y a moins d'une heure (juste pour vérifier si l'accu est toujours utilisé), y a-t-il une raison particulière pour laquelle vous n'avez accepté aucune des réponses ci-dessous?
Fabian N.

Réponses:

731

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é :-)

paxdiablo
la source
29
C'est une excellente solution de contournement, à tel point que je pense que cela transcende sa maladresse
Question Mark
14
@ rubo77, seulement s'il a fallu moins d'une seconde pour s'exécuter :-) Si cela prenait 29 secondes, cela arriverait à 0:00:00, 0: 00.59, 0:01:00, 0:01:59 et ainsi de suite .
paxdiablo
1
Super sournois, très créatif!
K Raphael
2
À quoi servent les parenthèses rondes autour de la deuxième ligne?
Nigel Alderton
2
Il s'agit d'une belle solution à un problème qui, par ailleurs, paralyse l'efficacité des crons pour certaines tâches qui nécessitent une exécution en quelques fractions de minutes. Je vous remercie.
Fiddy Bux
67

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'\''
sauvage
la source
Cette syntaxe est-elle équivalente à celle de paxdiablo? Ou y a-t-il de subtiles différences?
Nicolas Raoul
La différence est: j'ai utilisé le chemin d'origine vers le binaire. @paxdiablo a utilisé une sorte de méta-syntaxe. (et invoque un sous-shell)
wildplasser
1
Je voulais dire, en utilisant &&au lieu de ( ; ).
Nicolas Raoul
2
Désolé. Non, il y a une différence; l' &&opérateur court-circuite, donc la commande suivante dans la chaîne n'est pas exécutée si la précédente a échoué.
Wildplasser
Cette granularité ne devrait pas être un problème pour une résolution inférieure à la minute.
juan Isaza
37

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
Marvin Pinto
la source
54
Gardez à l'esprit que ce n'est pas tout à fait la même chose. Si le travail prend 25 secondes (par exemple), il démarre toutes les 55 secondes plutôt que toutes les 30 secondes. Cela n'a peut-être pas d'importance, mais vous devez être conscient des conséquences possibles.
paxdiablo
7
Vous pouvez exécuter le travail en arrière-plan, puis il s'exécutera en presque exactement 30 secondes.
Chris Koston
1
alors que [vrai] dors 30 # faites ce dont vous avez besoin ici fait --------- fait devrait être en petit cas
temple
1
N'est-ce pas la while [ true ]raison pour laquelle vous avez beaucoup d'instances du même script, car cron en lancera un nouveau toutes les minutes?
Carcamano
2
Vous pouvez faire sleep $remainingTimeoù le temps restant est de 30 moins le temps pris par le travail (et le plafonner à zéro s'il a pris> 30 secondes). Vous prenez donc le temps avant et après le travail réel et calculez la différence.
mahemoff
32

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:

Guss
la source
2
Je trouve souvent de meilleures réponses comme celle-ci dans la section des commentaires. À mon humble avis, bien que cron ait été un aliment de base pour les travaux planifiés, cette réponse devrait être acceptée car ce n'est pas un "travail de piratage" de sommeil et risquant de paralléliser l'exécution de tâches de longue durée compte tenu de l'intervalle / fréquence nécessaire
Qiqo
2
superbe réponse, devrait être la réponse sélectionnée
GuidedHacking
21

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

Andrew
la source
11
Remarque: cela ne fonctionne correctement que si le script prend moins d'une seconde à s'exécuter
rubo77
2
Rubo - si le travail prend quelques secondes (au lieu de milli ou microsecondes) pour se terminer, vous ne l'exécuterez pas toutes les trente secondes pour pouvoir l'exécuter deux fois par minute. Alors oui, commencez par 30 puis soustrayez de cela le nombre approximatif de secondes par exécution, s'il est supérieur à 1 seconde.
Andrew
2
Cela n'aide pas non plus si vous souhaitez recevoir des rapports d'erreur pour chaque exécution séparément.
joeln
joelin - la commande que je donne n'empêche pas d'obtenir des données de journal ou de sortie, j'ai simplifié la commande pour répondre à la question. Pour capturer la journalisation, chaque commande peut / devrait avoir une sortie redirigée si vous avez besoin de la journalisation, par exemple script / rails runner -e production '\' 'Song.insert_latest' \ '' pourrait être écrit comme script / rails runner -e production '\' 'Song.insert_latest' \ '' 2> & 1> / path_to_logfile et à nouveau peut être fait pour chaque commande dans la seule entrée cron.
Andrew
13

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

shlomia
la source
10

Utilisez la montre:

$ watch --interval .30 script_to_run_every_30_sec.sh
user7079817
la source
puis-je utiliser quelque chose comme $ watch --interval .10 php some_file.php? ou watchfonctionne uniquement avec des fichiers .sh?
Yevhenii Shashkov
Vous pouvez exécuter n'importe quoi avec la montre. Cependant, l'intervalle se situe entre la fin et le début de la commande suivante, --interval .30ne s'exécutera donc pas deux fois par minute. C'est-à-dire watch -n 2 "sleep 1 && date +%s"qu'il augmentera toutes les 3 secondes.
jmartori
veuillez noter qu'il a watchété conçu pour être utilisé par un terminal, donc - bien qu'il puisse fonctionner sans terminal (exécuté avec nohuppuis se déconnecter) ou avec un faux terminal (tel que screen) - il n'a pas les moyens de se comporter comme un cron, comme la récupération après une panne, redémarrage après le démarrage, etc '.
Guss
9

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 &
Pankaj Shinde
la source
4
Le temps va dériver. Par exemple, si l' backup.shexécution prend 1,5 seconde, il s'exécutera toutes les 6,5 secondes. Il y a des façons d'éviter cela, par exemplesleep $((5 - $(date +%s) % 5))
Keith Thompson
Je suis nouveau sur nohup, lors de l'exécution de votre exemple, nohup renvoie «aucun fichier ou répertoire». Après quelques recherches, vous semblez avoir raté «sh» après nohup. Comme ceci: $ nohup sh ./every-5-seconds.sh &
VHanded
6

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!

Adi Chiru
la source
1
Confessions d'un développeur PHP; )
Eric Kigathi
3
En fait, les aveux d'un ingénieur système permettant aux développeurs PHP .... :)
Adi Chiru
6

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

lingyfh
la source
4

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.

sujoshi
la source
Vous souhaiterez probablement passer YOUR_COMMANDSà YOUR_COMMANDS &, afin que la commande soit lancée en arrière-plan, sinon, si la commande prend plus d'une fraction de seconde - cela retardera le prochain lancement. Donc avec X = 2 et Y = 30, si la commande prend 10 secondes - elle se lancera à la minute puis 40 secondes plus tard, au lieu de 30. Bravo à @paxdiablo.
Guss
Pour une raison quelconque, si j'omet la /bin/bash -cpartie (y compris les guillemets d'argument), le script ne s'exécute que toutes les minutes, en ignorant l'itération (dans mon cas X=12et Y=5).
abiyi
3

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
szaier
la source
2
si je comprends bien, ce script s'exécute 30 fois et attend 30 secondes entre chaque itération. Comment est-il logique de l'exécuter toutes les minutes en cron?
FuzzyAmi
2

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
Nguyen Nguyen
la source
1

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 
jfajunior
la source
que représente 1-6?
Phantom007
@ Phantom007 1-6 représente du lundi au samedi, où "-" est une plage et "0" est le dimanche. Voici un bon lien qui explique très bien tous les champs et où vous pouvez le tester: " crontab.guru/# * _ * _ * _ * _ 1-6"
jfajunior
1

é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

Aditya Gosavi
la source
0

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 ...)

Thomas
la source
0

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.

bnoeafk
la source
-1

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
Lo Vega
la source
Même en supposant que cela 60devrait être un 30, vous voudrez peut-être le déplacer wget à l' intérieur de l' ifinstruction, sinon il est exécuté chaque seconde. En tout cas, je ne sais pas en quoi c'est mieux qu'un simple sleep 30. Si vous surveilliez l'heure UNIX réelle plutôt que votre compteur, cela ferait une différence.
paxdiablo
en écho à l'impression du compteur, vous pouvez découvrir le temps retardé par EXCUTE COMMAND s'il n'est PAS exécuté wget en arrière-plan.
Lo Vega