Comment créer une tâche cron en utilisant automatiquement Bash sans l’éditeur interactif?

Est-ce que crontab a un argument pour créer des tâches cron sans utiliser l’éditeur (crontab -e). Si oui, quel serait le code créer un cronjob à partir d’un script Bash?

Vous pouvez append à la crontab comme suit:

#write out current crontab crontab -l > mycron #echo new cron into cron file echo "00 09 * * 1-5 echo hello" >> mycron #install new cron file crontab mycron rm mycron 

Explication de la ligne Cron

 * * * * * "command to be executed" - - - - - | | | | | | | | | ----- Day of week (0 - 7) (Sunday=0 or 7) | | | ------- Month (1 - 12) | | --------- Day of month (1 - 31) | ----------- Hour (0 - 23) ------------- Minute (0 - 59) 

Source nixCraft .

Vous pourrez peut-être le faire à la volée

 crontab -l | { cat; echo "0 0 0 0 0 some entry"; } | crontab - 

crontab -l liste les travaux crontab en cours, cat imprime, echo imprime la nouvelle commande et crontab - ajoute tous les éléments imprimés au fichier crontab. Vous pouvez voir l’effet en faisant un nouveau crontab -l .

Cette version plus courte ne nécessite aucun fichier temporaire, elle est insensible aux insertions multiples et vous permet de modifier la planification d’une entrée existante.

Disons que vous avez ces:

 croncmd="/home/me/myfunction myargs > /home/me/myfunction.log 2>&1" cronjob="0 */15 * * * $croncmd" 

Pour l’append à la crontab, sans duplication:

 ( crontab -l | grep -v -F "$croncmd" ; echo "$cronjob" ) | crontab - 

Pour le retirer du crontab quel que soit son planning actuel:

 ( crontab -l | grep -v -F "$croncmd" ) | crontab - 

Remarques:

  • grep -F correspond littéralement à la chaîne, car nous ne voulons pas l’interpréter comme une expression régulière
  • Nous ignorons également la planification du temps et ne recherchons que la commande. Par ici; l’horaire peut être modifié sans risque d’append une nouvelle ligne à la crontab

Merci à tous pour votre aide. En assemblant ce que j’ai trouvé ici et ailleurs, j’ai trouvé ceci:

Le code

 command="php $INSTALL/indefero/scripts/gitcron.php" job="0 0 * * 0 $command" cat <(fgrep -i -v "$command" <(crontab -l)) <(echo "$job") | crontab - 

Je ne pouvais pas trouver comment éliminer le besoin des deux variables sans me répéter.

command est évidemment la commande que je veux programmer. job prend $command et ajoute les données de planification. J'ai eu besoin des deux variables séparément dans la ligne de code qui fait le travail.

Détails

  1. Crédit à duckyflip, j'utilise cette petite redirection thingy ( <(*command*) ) pour transformer la sortie de crontab -l en entrée pour la commande fgrep .
  2. fgrep filtre ensuite les correspondances de $command (option -v ), insensible à la casse (option -i ).
  3. Encore une fois, le petit object de redirection ( <(*command*) ) est utilisé pour rétablir le résultat en entrée pour la commande cat .
  4. La commande cat reçoit également echo "$job" (explicite), grâce à l'utilisation de la redirection thingy ( <(*command*) ).
  5. Donc, la sortie filtrée de crontab -l et le simple echo "$job" , combinés, sont transférés ('|') vers crontab - pour finalement être écrits.
  6. Et ils ont tous vécu heureux pour toujours!

En un mot:

Cette ligne de code filtre les tâches cron correspondant à la commande, puis écrit les tâches cron restantes avec la nouvelle, agissant ainsi comme une fonction "Ajouter" ou "Mettre à jour". Pour ce faire, il vous suffit de remplacer les valeurs job variables de command et de job .

EDIT (écrasement fixe):

 cat <(crontab -l) <(echo "1 2 3 4 5 scripty.sh") | crontab - 

Il y a eu beaucoup de bonnes réponses concernant l’utilisation de crontab, mais aucune mention d’une méthode plus simple, comme l’utilisation de cron .

Utiliser cron parti des fichiers système et des répertoires situés dans /etc/crontab , /etc/cron.daily,weekly,hourly ou /etc/cron.d/ :

 cat > /etc/cron.d/ << EOF SHELL=/bin/bash PATH=/sbin:/bin:/usr/sbin:/usr/bin MAILTO=root HOME=/ 01 * * * *   EOF 

Dans l’exemple ci-dessus, nous avons créé un fichier dans /etc/cron.d/ , fourni les variables d’environnement pour l’exécution réussie de la commande et fourni à l’ user la commande et la command elle-même. Ce fichier ne doit pas être exécutable et le nom ne doit contenir que des caractères alphanumériques et des traits d’union (plus de détails ci-dessous).

Pour donner une réponse complète, regardons les différences entre crontab vs cron/crond :

 crontab -- maintain tables for driving cron for individual users 

Pour ceux qui souhaitent exécuter le travail dans le contexte de leur utilisateur sur le système, l’utilisation de crontab peut être parfaitement logique.

 cron -- daemon to execute scheduled commands 

Pour ceux qui utilisent la gestion de la configuration ou veulent gérer les travaux pour d’autres utilisateurs, dans ce cas, nous devons utiliser cron .

Un extrait rapide des pages de manuel vous donne quelques exemples de quoi faire ou ne pas faire:

/ etc / crontab et les fichiers de /etc/cron.d doivent appartenir à root et ne doivent pas être accessibles en écriture de groupe ou autre. Contrairement à la zone de spool, les fichiers sous /etc/cron.d ou les fichiers sous /etc/cron.hourly, /etc/cron.daily, /etc/cron.weekly et /etc/cron.monthly peuvent également être des liens symboliques, à condition que le lien symbolique et le fichier sur lesquels il pointe soient la propriété de root. Les fichiers sous /etc/cron.d n’ont pas besoin d’être exécutables, alors que les fichiers sous /etc/cron.hourly, /etc/cron.daily, /etc/cron.weekly et /etc/cron.monthly le font, comme ils sont exécutés par des parties d’exécution (voir run-parts (8) pour plus d’informations).

Source: http://manpages.ubuntu.com/manpages/trusty/man8/cron.8.html

La gestion de cette manière est plus facile et plus évolutive du sharepoint vue du système, mais ne sera pas toujours la meilleure solution.

Il y a des chances que vous automatisiez cela et que vous ne vouliez pas qu’un seul travail soit ajouté deux fois. Dans ce cas, utilisez:

 CRON="1 2 3 4 5 /root/bin/backup.sh" cat < (crontab -l) |grep -v "${CRON}" < (echo "${CRON}") 

Cela ne fonctionne que si vous utilisez BASH. Je ne connais pas la syntaxe DASH ( sh ) correcte.

Une variante qui édite uniquement crontab si la chaîne souhaitée n’y est pas trouvée:

 CMD="/sbin/modprobe fcpci" JOB="@reboot $CMD" TMPC="mycron" grep "$CMD" -q <(crontab -l) || (crontab -l>"$TMPC"; echo "$JOB">>"$TMPC"; crontab "$TMPC") 

Pour une création / remplacement rapide et sale d’un crontab avec un script BASH, j’ai utilisé cette notation:

 crontab < 

Si vous utilisez Vixie Cron, par exemple sur la plupart des dissortingbutions Linux, vous pouvez simplement placer un fichier dans /etc/cron.d avec le cronjob individuel.

Cela ne fonctionne que pour root bien sûr. Si votre système le supporte, vous devriez y voir plusieurs exemples. (Notez le nom d’utilisateur inclus dans la ligne, dans la même syntaxe que l’ancien / etc / crontab)

Il est sortingste de constater qu’il n’y a aucun moyen de gérer cela en tant qu’utilisateur régulier, et que de nombreuses implémentations cron n’ont aucun moyen de gérer cela.

Voici une fonction bash pour append une commande à crontab sans duplication

 function addtocrontab () { local frequency=$1 local command=$2 local job="$frequency $command" cat <(fgrep -i -v "$command" <(crontab -l)) <(echo "$job") | crontab - } addtocrontab "0 0 1 * *" "echo hello" 
 CRON="1 2 3 4 5 /root/bin/backup.sh" cat < (crontab -l) |grep -v "${CRON}" < (echo "${CRON}") 

Ajouter le paramètre -w à la commande grep exact, sans que le paramètre -w ajoutant la tâche cronjob "teste" entraîne la suppression du travail cron "test123"

fonction de script pour append / supprimer des cronjobs. aucune entrée de duplication:

 cronjob_editor () { # usage: cronjob_editor '' ''  if [[ -z "$1" ]] ;then printf " no interval specified\n" ;fi if [[ -z "$2" ]] ;then printf " no command specified\n" ;fi if [[ -z "$3" ]] ;then printf " no action specified\n" ;fi if [[ "$3" == add ]] ;then # add cronjob, no duplication: ( crontab -l | grep -v -F -w "$2" ; echo "$1 $2" ) | crontab - elif [[ "$3" == remove ]] ;then # remove cronjob: ( crontab -l | grep -v -F -w "$2" ) | crontab - fi } cronjob_editor "$1" "$2" "$3" 

testé:

 $ ./cronjob_editor.sh '*/10 * * * *' 'echo "this is a test" > export_file' add $ crontab -l $ */10 * * * * echo "this is a test" > export_file 

Non, crontab ne permet pas de modifier les fichiers cron.

Vous devez: prendre le fichier cron actuel (crontab -l> newfile), le changer et mettre le nouveau fichier en place (crontab newfile).

Si vous êtes familier avec perl, vous pouvez utiliser ce module Config :: Crontab .

LLP, Andrea

fonction de script pour append des cronjobs. vérifier les entrées en double, les expressions utilisables *> ”

 cronjob_creator () { # usage: cronjob_creator '' '' if [[ -z $1 ]] ;then printf " no interval specified\n" elif [[ -z $2 ]] ;then printf " no command specified\n" else CRONIN="/tmp/cti_tmp" crontab -l | grep -vw "$1 $2" > "$CRONIN" echo "$1 $2" >> $CRONIN crontab "$CRONIN" rm $CRONIN fi } 

testé:

 $ ./cronjob_creator.sh '*/10 * * * *' 'echo "this is a test" > export_file' $ crontab -l $ */10 * * * * echo "this is a test" > export_file 

source: mon cerveau;)

Vous pouvez probablement changer l’éditeur par défaut en ed et utiliser un heredoc pour éditer.

 EDITOR=ed export EDITOR crontab -e << EOF > a > * * * * * Myscript > * * * * * AnotherScript > * * * * * MoreScript > . > w > q > EOF 

Notez que le début de ce code signifie que la touche retour / entrée est enfoncée pour créer une nouvelle ligne.

Le a signifie APPEND pour ne rien écraser.

Le . signifie que vous avez terminé l’édition.

Le w signifie ÉCRIRE les modifications.

Le q signifie QUITTER ou édité.

vous pouvez le vérifier

 crontab -l 

Vous pouvez également supprimer une entrée.

 EDITOR=ed export EDITOR crontab -e << EOF > /Myscript/ > d > . > w > q > EOF 

Cela supprimera l’entrée crontab avec Myscript.

Le d signifie supprimer le motif à l’intérieur du / / .

Non vérifier à nouveau

 crontab -l 

Cette solution fonctionne aussi dans un script moins le > bien sûr 🙂