Menjalankan cron setiap 30 detik

Ok jadi saya punya cron yang harus saya jalankan setiap 30 detik.

Inilah yang saya miliki:

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

Ini berjalan, tetapi apakah ini berjalan setiap 30 menit atau 30 detik?

Juga, saya telah membaca bahwa cron mungkin bukan alat terbaik untuk digunakan jika saya sering menjalankannya. Apakah ada alat lain yang lebih baik yang bisa saya gunakan atau instal di Ubuntu 11.04 yang akan menjadi pilihan yang lebih baik? Apakah ada cara untuk memperbaiki cron di atas?

Anda memiliki */30di menit specifier - yang berarti setiap menit namun dengan langkah 30 (dengan kata lain, setiap setengah jam). Karena crontidak turun ke resolusi sub-menit, Anda perlu menemukan cara lain.

Satu kemungkinan, meskipun ini sedikit kludge ^(a) , adalah memiliki dua pekerjaan, satu diimbangi dengan 30 detik:

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

Anda akan melihat saya telah menambahkan komentar dan diformat untuk memastikan mudahnya menyinkronkannya.

Kedua cronpekerjaan benar-benar berjalan setiap menit tetapi yang terakhir akan menunggu setengah menit sebelum mengeksekusi "daging" pekerjaan /path/to/executable,.

Untuk cronopsi (non- berbasis) lainnya, lihat jawaban lain di sini, terutama yang menyebutkan fcrondan systemd. Ini mungkin lebih baik dengan asumsi sistem Anda memiliki kemampuan untuk menggunakannya (seperti menginstal fcronatau memiliki distro systemddengannya).

Jika Anda tidak ingin menggunakan solusi kludgy, Anda dapat menggunakan solusi berbasis loop dengan sedikit modifikasi. Anda masih harus mengelola agar proses Anda tetap berjalan dalam beberapa bentuk tetapi, setelah diurutkan, skrip berikut akan berfungsi:

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

Caranya adalah dengan menggunakan sleep 30tetapi untuk memulainya di latar belakang sebelum payload Anda berjalan. Kemudian, setelah payload selesai, tunggu saja latar belakangnya sleepselesai.

Jika payload mengambil ndetik (di mana n <= 30), menunggu setelah payload kemudian akan menjadi 30 - ndetik. Jika dibutuhkan lebih dari 30 detik, maka siklus berikutnya akan tertunda hingga payload selesai, tetapi tidak lagi.

Anda akan melihat bahwa saya memiliki kode debug di sana untuk memulai pada batas satu menit untuk membuat output awalnya lebih mudah diikuti. Saya juga secara bertahap meningkatkan waktu payload maksimum sehingga pada akhirnya Anda akan melihat payload melebihi waktu siklus 30 detik (garis kosong tambahan adalah output sehingga efeknya jelas).

Contoh dijalankan berikut (di mana siklus biasanya dimulai 30 detik setelah siklus sebelumnya):

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

Jika Anda ingin menghindari solusi kludgy, ini mungkin lebih baik. Anda masih membutuhkan cronpekerjaan (atau yang setara) untuk mendeteksi secara berkala jika skrip ini berjalan dan, jika tidak, mulai saja. Tapi skrip itu sendiri yang mengatur waktu.

^(a) Beberapa teman kerja saya akan mengatakan bahwa kludges adalah keahlian saya :-)

Kamu tidak bisa Cron memiliki rincian 60 detik.

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

Granularity Cron dalam hitungan menit dan tidak dirancang untuk bangun setiap xdetik untuk menjalankan sesuatu. Jalankan tugas berulang Anda dalam satu lingkaran dan itu akan melakukan apa yang Anda butuhkan:

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

Jika Anda menjalankan OS Linux baru-baru ini dengan SystemD, Anda dapat menggunakan unit SystemD Timer untuk menjalankan skrip Anda pada tingkat granularitas yang Anda inginkan (secara teoritis hingga nanodetik), dan - jika Anda mau - aturan peluncuran yang jauh lebih fleksibel daripada yang pernah diizinkan Cron . Tidak sleepdiperlukan kludges

Dibutuhkan sedikit lebih banyak untuk mengatur daripada satu baris dalam file cron, tetapi jika Anda membutuhkan sesuatu yang lebih baik daripada "Setiap menit", itu sepadan dengan usaha.

Model timer SystemD pada dasarnya adalah ini: timer adalah unit yang memulai unit layanan ketika timer berlalu .

Jadi untuk setiap skrip / perintah yang ingin Anda jadwalkan, Anda harus memiliki unit layanan dan kemudian unit timer tambahan. Satu unit pengatur waktu dapat mencakup beberapa jadwal, sehingga Anda biasanya tidak memerlukan lebih dari satu pengatur waktu dan satu layanan.

Berikut adalah contoh sederhana yang mencatat "Hello World" setiap 10 detik:

/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

Setelah mengatur unit-unit ini (dalam /etc/systemd/system, seperti yang dijelaskan di atas, untuk pengaturan seluruh sistem, atau pada ~/.config/systemd/useruntuk pengaturan khusus pengguna), Anda perlu mengaktifkan timer (bukan layanan) dengan menjalankan systemctl enable --now helloworld.timer( --nowflag juga memulai timer segera, jika tidak, itu hanya akan mulai setelah boot berikutnya, atau login pengguna).

Bidang [Timer]bagian yang digunakan di sini adalah sebagai berikut:

• OnBootSec - Mulai layanan ini beberapa detik setelah setiap boot.
• OnUnitActiveSec- Mulai layanan ini beberapa detik setelah layanan terakhir kali dimulai. Inilah yang menyebabkan timer berulang dan berperilaku seperti tugas cron.
• AccuracySec- mengatur keakuratan timer. Pengatur waktu hanya seakurat yang ditetapkan bidang ini, dan standarnya adalah 1 menit (mengemulasi cron). Alasan utama untuk tidak menuntut keakuratan terbaik adalah untuk meningkatkan konsumsi daya - jika SystemD dapat menjadwalkan proses berikutnya untuk bertepatan dengan peristiwa lain, ia perlu membangunkan CPU lebih jarang. Dalam 1mscontoh di atas tidak ideal - Saya biasanya mengatur keakuratan 1(1 detik) dalam pekerjaan terjadwal sub-menit saya, tetapi itu berarti bahwa jika Anda melihat log yang menunjukkan pesan "Hello World", Anda akan melihat bahwa seringkali terlambat 1 detik. Jika Anda setuju dengan itu, saya sarankan untuk mengatur keakuratan 1 detik atau lebih.

Seperti yang mungkin Anda perhatikan, timer ini tidak meniru Cron dengan baik - dalam arti bahwa perintah tidak dimulai pada awal setiap periode jam dinding (yaitu tidak dimulai pada detik ke-10 pada jam, kemudian tanggal 20 dan seterusnya). Alih-alih hanya terjadi ketika timer elips. Jika sistem di-boot pada 12:05:37, maka pada saat perintah dijalankan akan pada 12:05:47, kemudian pada 12:05:57, dll. Jika Anda tertarik pada keakuratan jam dinding aktual, maka Anda dapat ingin mengganti OnBootSecdan OnUnitActiveSecladang dan bukan menetapkan OnCalendaraturan dengan jadwal yang Anda inginkan (yang sejauh yang saya mengerti tidak bisa lebih cepat dari 1 detik, menggunakan format kalender). Contoh di atas juga dapat ditulis sebagai:

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

Catatan terakhir: seperti yang Anda duga, helloworld.timerunit memulai helloworld.serviceunit karena mereka memiliki nama yang sama (minus akhiran tipe unit). Ini adalah default, tetapi Anda dapat menimpanya dengan mengatur Unitbidang untuk [Timer]bagian tersebut.

Lebih banyak detail berdarah dapat ditemukan di:

• Arch Linux Wiki halaman tentang penghitung waktu SystemD yang memberikan gambaran yang sangat baik tentang topik, dengan contoh.
• man systemd.timer
• man systemd.time
• man systemd.service
• man system.exec

Tidak perlu dua entri cron, Anda dapat memasukkannya ke dalam satu dengan:

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

jadi dalam kasus Anda:

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

Anda dapat memeriksa jawaban saya untuk pertanyaan serupa ini

Pada dasarnya, saya telah memasukkan di sana skrip bash bernama "runEvery.sh" yang dapat Anda jalankan dengan cron setiap 1 menit dan memberikan argumen sebagai perintah nyata yang ingin Anda jalankan dan frekuensi dalam detik di mana Anda ingin menjalankannya.

sesuatu seperti ini

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

Gunakan jam tangan:

$ watch --interval .30 script_to_run_every_30_sec.sh

Pekerjaan Cron tidak dapat digunakan untuk menjadwalkan pekerjaan dalam interval detik. yaitu Anda tidak dapat menjadwalkan pekerjaan cron untuk berjalan setiap 5 detik. Alternatifnya adalah dengan menulis skrip shell yang menggunakan sleep 5perintah di dalamnya.

Buat skrip shell every-5-seconds.sh menggunakan bash while, seperti ditunjukkan di bawah ini.

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

Sekarang, jalankan skrip shell ini di latar belakang menggunakan nohupseperti yang ditunjukkan di bawah ini. Ini akan terus mengeksekusi skrip bahkan setelah Anda keluar dari sesi Anda. Ini akan menjalankan skrip shell backup.sh Anda setiap 5 detik.

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

Gunakan fcron ( http://fcron.free.fr/ ) - memberi Anda rincian dalam hitungan detik dan jauh lebih baik dan lebih kaya fitur daripada cron (vixie-cron) dan juga stabil. Saya biasa membuat hal-hal bodoh seperti memiliki sekitar 60 skrip php yang berjalan pada satu mesin dalam pengaturan yang sangat bodoh dan masih melakukan tugasnya!

dalam dir /etc/cron.d/

baru buat file excute_per_30s

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

akan menjalankan cron setiap 30 detik

Saat ini saya menggunakan metode di bawah ini. Bekerja tanpa masalah.

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

Jika Anda ingin menjalankan setiap N detik kemudian X akan 60 / N dan Y akan N .

Terima kasih.

Pekerjaan Crontab dapat digunakan untuk menjadwalkan pekerjaan dalam hitungan menit / jam / hari, tetapi tidak dalam hitungan detik. Alternatifnya:

Buat skrip untuk dieksekusi setiap 30 detik:

#!/bin/bash
# 30sec.sh

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

Gunakan crontab -edan crontab untuk menjalankan skrip ini:

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

Anda dapat menjalankan skrip itu sebagai layanan, restart setiap 30 detik

Daftarkan layanan

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

Tempel di perintah di bawah ini

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

Muat ulang layanan

sudo systemctl daemon-reload

Aktifkan layanan

sudo systemctl enable YOUR_SERVICE_NAME

Mulai layanan

sudo systemctl start YOUR_SERVICE_NAME

Periksa status layanan Anda

systemctl status YOUR_SERVICE_NAME

Terima kasih atas semua jawaban yang baik. Untuk membuatnya lebih sederhana, saya menyukai solusi campuran, dengan kontrol pada crontab dan pembagian waktu pada skrip. Jadi inilah yang saya lakukan untuk menjalankan skrip setiap 20 detik (tiga kali per menit). Garis crontab:

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

Naskah:

cd /home/a/b/checkAgenda

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

tulis satu skrip shell buat file .sh

nano every30second.sh

dan menulis skrip

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

kemudian atur cron untuk skrip ini crontab -e

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

file .sh panggilan cron ini dalam setiap 1 menit & dalam perintah file .sh dijalankan 2 kali dalam 1 menit

jika Anda ingin menjalankan skrip selama 5 detik, ganti 30 dengan 5 dan ubah untuk loop seperti ini: For (( i=1; i <= 12; i++ ))

Ketika Anda memilih untuk setiap detik maka hitung 60 / detik Anda dan tulis di For loop

Saya hanya punya tugas serupa untuk dilakukan dan menggunakan pendekatan berikut:

nohup watch -n30 "kill -3 NODE_PID" &

Saya perlu melakukan kill -3 berkala (untuk mendapatkan jejak stack dari suatu program) setiap 30 detik selama beberapa jam.

nohup ... & 

Ini di sini untuk memastikan bahwa saya tidak kehilangan pelaksanaan arloji jika saya kehilangan shell (masalah jaringan, windows crash dll ...)

Lihatlah sering-cron - ini sudah tua tetapi sangat stabil dan Anda dapat mundur ke mikro-detik. Pada titik ini, satu-satunya hal yang akan saya katakan menentangnya adalah bahwa saya masih mencoba mencari cara menginstalnya di luar init.d tetapi sebagai layanan systemd asli, tetapi tentu saja hingga Ubuntu 18 itu berjalan hanya baik masih menggunakan init.d (jarak dapat bervariasi pada versi terakhir). Ini memiliki keuntungan tambahan (?) Untuk memastikan bahwa ia tidak akan menelurkan contoh lain dari skrip PHP kecuali yang sebelumnya telah selesai, yang mengurangi potensi masalah kebocoran memori.

Jalankan dalam loop shell, contoh:

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