Her 30 saniyede bir cron çalıştırmak

Tamam, 30 saniyede bir çalıştırmam gereken bir cronum var.

İşte ne var:

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

Çalışıyor, ancak bu her 30 dakikada bir mi yoksa 30 saniyede mi çalışıyor?

Ayrıca, sık sık çalıştırırsam cron'un kullanmak için en iyi araç olmayabileceğini okuyordum. Daha iyi bir seçenek olacak Ubuntu 11.04 üzerinde kullanabileceğim veya yükleyebileceğim başka bir daha iyi araç var mı? Yukarıdaki cron'u düzeltmenin bir yolu var mı?

You have */30içinde dakika belirteci - araçlarının her dakika ama (başka bir deyişle, her yarım saatte bir) 30 kişilik bir adımla. Yana cronalt dakikalık çözünürlükleri aşağı gitmez, başka bir yol bulmak gerekir.

Bir olasılık, biraz çamur ^(a) olsa da , biri 30 saniye ofset olmak üzere iki işe sahip olmaktır:

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

Yorumları senkronize etmenin kolay olmasını sağlamak için yorum eklediğimi ve biçimlendirdiğimi göreceksiniz.

Her iki croniş de aslında her dakika çalışır ancak ikincisi işin "etini" uygulamadan önce yarım dakika bekler /path/to/executable.

Diğer (non İçin crontabanlı) seçenekleri, burada diğer cevaplar, söz özellikle olanları görmek fcronve systemd. Bunlar muhtemelen sisteminizin bunları kullanma yeteneğine sahip olduğunu varsayarsak (kurulum fcronveya dağıtım ile dağıtım systemdgibi).

Eğer varsa yok kludgy çözümü kullanmak istiyorum, küçük değişikliklerle bir döngü tabanlı çözümü kullanabilirsiniz. İşleminizin bir şekilde çalışmasını sağlamaya devam etmeniz gerekir, ancak bir kez sıralandığında, aşağıdaki komut dosyasının çalışması gerekir:

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

İşin püf noktası, yararlı yükünüz sleep 30çalışmaya başlamadan önce arka planda başlatmak için bir ama kullanmaktır . Sonra, yük bittikten sonra, arka planın sleepbitmesini bekleyin .

Yükün nsaniye (burada n <= 30) sürmesi durumunda, yükten sonraki bekleme süresi 30 - nsaniye olacaktır . O alırsa daha 30 saniyeden yükü artık bitmiş, ama kadar, bir sonraki döngü gecikecektir.

Çıktıyı takip etmeyi kolaylaştırmak için bir dakikalık bir sınırda başlamak için orada hata ayıklama kodum olduğunu göreceksiniz. Ayrıca, maksimum yük kapasitesini de kademeli olarak artırıyorum, böylece yükün 30 saniyelik döngü süresini aştığını göreceksiniz (ekstra bir boş satır çıktı, böylece etki açıktır).

Bir örnek çalışma takip eder (döngüler normalde bir önceki döngüden 30 saniye sonra başlar):

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

Kludgy çözümünden kaçınmak istiyorsanız, bu muhtemelen daha iyidir. cronBu komut dosyasının çalışıp çalışmadığını düzenli aralıklarla saptamak için bir işe (veya eşdeğerine) ihtiyacınız vardır ve eğer başlamazsa başlatın. Ancak betiğin kendisi zamanlamayı işler.

^(a) Bazı çalışma arkadaşlarım kludge'ların benim uzmanlık alanım olduğunu söyler :-)

Yapamazsın. Cron 60 saniyelik bir ayrıntıya sahiptir.

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

Cron en ayrıntı dakika içinde olup olmadığını her uyanmak için tasarlanmış xbir şey çalıştırmak saniye. Yinelenen görevinizi bir döngü içinde çalıştırın ve ihtiyacınız olanı yapmalıdır:

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

SystemD ile yeni bir Linux işletim sistemi kullanıyorsanız, komut dosyanızı istediğiniz herhangi bir ayrıntı düzeyinde (teorik olarak nanosaniyeye kadar) çalıştırmak için - ve isterseniz - Cron'un izin verdiği kadar çok daha esnek başlatma kurallarını çalıştırmak için SystemD Zamanlayıcı birimini kullanabilirsiniz. . Hiçbir sleepkludges gerekli

Bir cron dosyasında tek bir satırdan kurmak biraz daha zaman alır, ancak "Her dakika" dan daha iyi bir şeye ihtiyacınız varsa, çabaya değer.

SystemD zamanlayıcı modeli temel olarak şudur: zamanlayıcılar, bir zamanlayıcı geçtiğinde servis birimlerini başlatan birimlerdir .

Bu nedenle, zamanlamak istediğiniz her komut dosyası / komut için bir hizmet birimine ve ardından ek bir zamanlayıcı birimine sahip olmalısınız. Tek bir zamanlayıcı ünitesi birden fazla zamanlama içerebilir, bu nedenle normalde birden fazla zamanlayıcıya ve bir servise ihtiyacınız olmaz.

İşte "Merhaba Dünya" yı her 10 saniyede bir kaydeden basit bir örnek:

/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

Bu birimleri kurduktan sonra ( /etc/systemd/systemyukarıda açıklandığı gibi, sistem çapında bir ayar ~/.config/systemd/useriçin veya kullanıcıya özel kurulum için), çalıştırarak zamanlayıcıyı (hizmeti değil) etkinleştirmeniz gerekir systemctl enable --now helloworld.timer( --nowbayrak da zamanlayıcıyı başlatır) hemen, aksi takdirde, yalnızca bir sonraki önyükleme veya kullanıcı oturum açmasından sonra başlayacaktır).

[Timer]Aşağıdaki gibi burada kullanılan bölüm alanları şunlardır:

• OnBootSec - her önyüklemeden bu kadar saniye sonra hizmeti başlatın.
• OnUnitActiveSec- servisin son başlatılmasından bu kadar saniye sonra hizmeti başlatın. Zamanlayıcının kendini tekrar etmesine ve bir cron işi gibi davranmasına neden olan şey budur.
• AccuracySec- zamanlayıcının doğruluğunu ayarlar. Zamanlayıcılar yalnızca bu alanın ayarladığı doğruluktadır ve varsayılan değer 1 dakikadır (cron öykünür). En iyi doğruluğu talep etmemenin ana nedeni güç tüketimini arttırmaktır - eğer SystemD bir sonraki çalıştırmayı diğer olaylarla çakışacak şekilde zamanlayabilirse, CPU'yu daha az uyandırması gerekir. 1msBen genellikle set doğruluk - Yukarıdaki örnekte ideal değildir 1benim alt dakikalık planlanan işlerde (1 saniye), ama bu "Merhaba Dünya" mesajlarını gösteren günlüğüne bakarsanız, bunu görürdük anlamına geleceğini genellikle 1 saniye gecikir. Bu konuda sorun yoksa, doğruluğu 1 saniye veya daha fazla olarak ayarlamanızı öneririm.

Fark etmiş olabileceğiniz gibi, bu zamanlayıcı Cron'u o kadar iyi taklit etmiyor - yani komut her duvar saati periyodunun başında başlamıyor (yani saatin 10. saniyesinde başlamıyor, sonra 20. vb.). Bunun yerine sadece zamanlayıcı elipse olur. Sistem 12:05:37'de önyükleme yaptıysa, komutun bir sonraki çalıştırılışında 12:05:47, daha sonra 12:05:57, vb. Olacaktır. Gerçek duvar saati doğruluğu ile ilgileniyorsanız, OnBootSecve OnUnitActiveSecalanlarını değiştirmek ve bunun yerine OnCalendaristediğiniz zamanlamayı içeren bir kural ayarlamak (ki bu, anladığım kadarıyla takvim biçimini kullanarak 1 saniyeden daha hızlı olamaz). Yukarıdaki örnek ayrıca şu şekilde de yazılabilir:

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

Son not: muhtemelen tahmin ettiğiniz gibi, helloworld.timerünite helloworld.serviceaynı ada sahip oldukları için üniteyi başlatır (eksi ünite tipi son eki). Bu varsayılan ayardır, ancak bölüm için Unitalanı ayarlayarak bunu geçersiz kılabilirsiniz [Timer].

Daha fazla kanlı ayrıntıyı şu adreste bulabilirsiniz:

• Arch Linux Wiki sayfası hakkında SystemD zamanlayıcıları ile ilgili konuya çok iyi bir genel bakış, örnekler.
• man systemd.timer
• man systemd.time
• man systemd.service
• man system.exec

İki cron girişine gerek yoktur, aşağıdakilerle bire koyabilirsiniz:

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

yani sizin durumunuzda:

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

Bu benzer soruya cevabımı kontrol edebilirsiniz

Temel olarak, orada "runEvery.sh" adlı bir bash betiği her 1 dakikada bir cron ile çalıştırabilir ve çalıştırmak istediğiniz gerçek komutu ve çalıştırmak istediğiniz saniye cinsinden sıklığı argümanlar olarak iletebilirsiniz.

böyle bir şey

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

İzle kullanın:

$ watch --interval .30 script_to_run_every_30_sec.sh

Cron işi bir işi saniyeler içinde zamanlamak için kullanılamaz. Bir cron işini her 5 saniyede bir çalışacak şekilde zamanlayamazsınız. Alternatif, içinde komut kullanan bir kabuk betiği yazmaktır sleep 5.

Aşağıda gösterildiği gibi bash while döngüsünü kullanarak bir kabuk komut dosyası oluşturun.

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

Şimdi, bu kabuk komut dosyasını nohupaşağıda gösterildiği gibi arka planda çalıştırın . Bu, oturumunuzdan çıktıktan sonra bile komut dosyasını yürütmeye devam edecektir. Bu, backup.sh kabuk betiğinizi her 5 saniyede bir yürütür.

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

Fcron ( http://fcron.free.fr/ ) kullanın - saniyeler içinde ayrıntı düzeyi sağlar ve cron'dan (vixie -cron) zengin ve istikrarlı bir şekilde daha iyi ve daha fazla özellik sunar. Ben çok aptal ayarlarda bir makinede çalışan yaklaşık 60 php komut dosyaları gibi aptalca şeyler yapmak için kullanılır ve hala işini yaptı!

dir /etc/cron.d/

yeni bir dosya oluştur excute_per_30s

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

her 30 saniyede bir cron çalıştıracak

Şu anda aşağıdaki yöntemi kullanıyorum. Sorunsuz çalışır.

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

Her çalıştırmak istiyorsanız N saniye sonra X olacak 60 / N ve Y olacaktır N .

Teşekkür ederim.

Crontab işi bir işi dakika / saat / gün olarak planlamak için kullanılabilir, ancak saniyeler içinde değil. Alternatif :

Her 30 saniyede bir yürütülecek bir komut dosyası oluşturun:

#!/bin/bash
# 30sec.sh

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

crontab -eBu betiği çalıştırmak için ve bir crontab kullanın :

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

Bu komut dosyasını hizmet olarak çalıştırabilir, her 30 saniyede bir yeniden başlatabilirsiniz

Bir hizmet kaydedin

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

Aşağıdaki komutu yapıştırı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

Hizmetleri yeniden yükle

sudo systemctl daemon-reload

Hizmeti etkinleştir

sudo systemctl enable YOUR_SERVICE_NAME

Hizmeti başlat

sudo systemctl start YOUR_SERVICE_NAME

Hizmetinizin durumunu kontrol edin

systemctl status YOUR_SERVICE_NAME

Tüm iyi cevaplar için teşekkürler. Basitleştirmek için, crontab üzerindeki kontrol ve senaryodaki zaman bölümü ile karışık çözümü beğendim. Bu yüzden her 20 saniyede bir (her dakika üç kez) bir senaryo çalıştırmak için yaptım. Crontab satırı:

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

Senaryo:

cd /home/a/b/checkAgenda

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

bir kabuk betiği yaz .sh dosyası oluştur

nano Instagram Hesabındaki Resim ve Videoları every30second.sh

ve senaryo yaz

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

sonra bu betik için cron ayarlayın crontab -e

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

Bu cron çağrı .sh dosyası her 1 dakikada & .sh dosya komutunda 1 dakikada 2 kez çalıştırılır

komut dosyasını 5 saniye çalıştırmak istiyorsanız, 30'u 5 ile değiştirin ve döngü için şu şekilde değiştirin: For (( i=1; i <= 12; i++ ))

herhangi bir saniye için seçtiğinizde 60 / saniyenizi hesaplayın ve For döngüsüne yazın

Aşağıdaki yaklaşımı yapmak ve kullanmak için benzer bir görevim vardı:

nohup watch -n30 "kill -3 NODE_PID" &

Birkaç saat boyunca her 30 saniyede bir periyodik bir öldürme -3 (bir programın yığın izini almak için) olması gerekiyordu.

nohup ... & 

Bu, kabuğu kaybedersem saatin yürütülmesini kaybetmediğimden emin olmak için burada (ağ sorunu, windows çökmesi vb.)

Sık-cron'a bir göz atın - eski ama çok kararlı ve mikro saniyeye kadar inebilirsiniz. Bu noktada, buna karşı söyleyeceğim tek şey, hala init.d dışında nasıl kurulacağını çözmeye çalışıyorum, ancak yerel bir systemd hizmeti olarak, ancak kesinlikle Ubuntu 18'e kadar çalışıyor ince init.d kullanıyor (mesafe sonraki sürümlerde değişiklik gösterebilir). Önceden tamamlanmadığı sürece PHP betiğinin başka bir örneğini üretmemesini sağlamanın ek bir avantajı (?) Vardır ve bu da bellek sızıntısı sorunlarını azaltır.

Bir kabuk döngüsünde çalıştırın, örnek:

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