Comment répertorier tous les travaux cron pour tous les utilisateurs?

Existe-t-il une commande ou un script existant qui me permettra de visualiser tous les travaux cron planifiés d'un système * NIX à la fois? J'aimerais qu'il inclue tous les crontabs utilisateur, ainsi que /etc/crontabtout ce qui s'y trouve /etc/cron.d. Il serait également intéressant de voir les commandes spécifiques exécutées par run-partsdans /etc/crontab.

Idéalement, j'aimerais que la sortie soit sous forme de colonne agréable et ordonnée de manière significative.

Je pouvais ensuite fusionner ces listes à partir de plusieurs serveurs pour afficher le "calendrier des événements" global.

J'étais sur le point d'écrire un tel script moi-même, mais si quelqu'un a déjà eu des ennuis ...

Vous devrez l'exécuter en tant que root, mais:

for user in $(cut -f1 -d: /etc/passwd); do crontab -u $user -l; done

fera une boucle sur chaque nom d'utilisateur répertoriant leur crontab. Les crontabs appartiennent aux utilisateurs respectifs, vous ne pourrez donc pas voir la crontab d'un autre utilisateur sans être eux ou root.

Modifiez si vous voulez savoir à quel utilisateur appartient un crontab, utilisezecho $user

for user in $(cut -f1 -d: /etc/passwd); do echo $user; crontab -u $user -l; done

J'ai fini par écrire un script (j'essaie de m'enseigner les points les plus fins du script bash, c'est pourquoi vous ne voyez pas quelque chose comme Perl ici). Ce n'est pas exactement une simple affaire, mais elle fait la plupart de ce dont j'ai besoin. Il utilise la suggestion de Kyle pour rechercher des crontabs des utilisateurs individuels, mais traite aussi /etc/crontab(y compris les scripts lancés par run-partsdans /etc/cron.hourly, /etc/cron.dailyetc.) et les emplois dans le /etc/cron.drépertoire. Il prend tout cela et les fusionne dans un affichage quelque chose comme ceci:

mi     h    d  m  w  user      command
09,39  *    *  *  *  root      [ -d /var/lib/php5 ] && find /var/lib/php5/ -type f -cmin +$(/usr/lib/php5/maxlifetime) -print0 | xargs -r -0 rm
47     */8  *  *  *  root      rsync -axE --delete --ignore-errors / /mirror/ >/dev/null
17     1    *  *  *  root      /etc/cron.daily/apt
17     1    *  *  *  root      /etc/cron.daily/aptitude
17     1    *  *  *  root      /etc/cron.daily/find
17     1    *  *  *  root      /etc/cron.daily/logrotate
17     1    *  *  *  root      /etc/cron.daily/man-db
17     1    *  *  *  root      /etc/cron.daily/ntp
17     1    *  *  *  root      /etc/cron.daily/standard
17     1    *  *  *  root      /etc/cron.daily/sysklogd
27     2    *  *  7  root      /etc/cron.weekly/man-db
27     2    *  *  7  root      /etc/cron.weekly/sysklogd
13     3    *  *  *  archiver  /usr/local/bin/offsite-backup 2>&1
32     3    1  *  *  root      /etc/cron.monthly/standard
36     4    *  *  *  yukon     /home/yukon/bin/do-daily-stuff
5      5    *  *  *  archiver  /usr/local/bin/update-logs >/dev/null

Notez qu'il montre l'utilisateur et trie plus ou moins par heure et minute afin que je puisse voir le programme quotidien.

Jusqu'à présent, je l'ai testé sur Ubuntu, Debian et Red Hat AS.

#!/bin/bash

# System-wide crontab file and cron job directory. Change these for your system.
CRONTAB='/etc/crontab'
CRONDIR='/etc/cron.d'

# Single tab character. Annoyingly necessary.
tab=$(echo -en "\t")

# Given a stream of crontab lines, exclude non-cron job lines, replace
# whitespace characters with a single space, and remove any spaces from the
# beginning of each line.
function clean_cron_lines() {
    while read line ; do
        echo "${line}" |
            egrep --invert-match '^($|\s*#|\s*[[:alnum:]_]+=)' |
            sed --regexp-extended "s/\s+/ /g" |
            sed --regexp-extended "s/^ //"
    done;
}

# Given a stream of cleaned crontab lines, echo any that don't include the
# run-parts command, and for those that do, show each job file in the run-parts
# directory as if it were scheduled explicitly.
function lookup_run_parts() {
    while read line ; do
        match=$(echo "${line}" | egrep -o 'run-parts (-{1,2}\S+ )*\S+')

        if [[ -z "${match}" ]] ; then
            echo "${line}"
        else
            cron_fields=$(echo "${line}" | cut -f1-6 -d' ')
            cron_job_dir=$(echo  "${match}" | awk '{print $NF}')

            if [[ -d "${cron_job_dir}" ]] ; then
                for cron_job_file in "${cron_job_dir}"/* ; do  # */ <not a comment>
                    [[ -f "${cron_job_file}" ]] && echo "${cron_fields} ${cron_job_file}"
                done
            fi
        fi
    done;
}

# Temporary file for crontab lines.
temp=$(mktemp) || exit 1

# Add all of the jobs from the system-wide crontab file.
cat "${CRONTAB}" | clean_cron_lines | lookup_run_parts >"${temp}" 

# Add all of the jobs from the system-wide cron directory.
cat "${CRONDIR}"/* | clean_cron_lines >>"${temp}"  # */ <not a comment>

# Add each user's crontab (if it exists). Insert the user's name between the
# five time fields and the command.
while read user ; do
    crontab -l -u "${user}" 2>/dev/null |
        clean_cron_lines |
        sed --regexp-extended "s/^((\S+ +){5})(.+)$/\1${user} \3/" >>"${temp}"
done < <(cut --fields=1 --delimiter=: /etc/passwd)

# Output the collected crontab lines. Replace the single spaces between the
# fields with tab characters, sort the lines by hour and minute, insert the
# header line, and format the results as a table.
cat "${temp}" |
    sed --regexp-extended "s/^(\S+) +(\S+) +(\S+) +(\S+) +(\S+) +(\S+) +(.*)$/\1\t\2\t\3\t\4\t\5\t\6\t\7/" |
    sort --numeric-sort --field-separator="${tab}" --key=2,1 |
    sed "1i\mi\th\td\tm\tw\tuser\tcommand" |
    column -s"${tab}" -t

rm --force "${temp}"

Sous Ubuntu ou debian, vous pouvez afficher crontab par /var/spool/cron/crontabs/ puis un fichier pour chaque utilisateur s'y trouve. Bien sûr, cela ne concerne que les crontab spécifiques à l'utilisateur.

Pour Redhat 6/7 et Centos, le crontab est sous /var/spool/cron/.

Cela montrera toutes les entrées crontab de tous les utilisateurs.

sed 's/^\([^:]*\):.*$/crontab -u \1 -l 2>\&1/' /etc/passwd | grep -v "no crontab for" | sh

Dépend de votre version linux mais j'utilise:

tail -n 1000 /var/spool/cron/*

en tant que root. Très simple et très court.

Me donne une sortie comme:

==> /var/spool/cron/root <==
15 2 * * * /bla

==> /var/spool/cron/my_user <==
*/10 1 * * * /path/to/script

Un petit raffinement de la réponse de Kyle Burton avec un formatage de sortie amélioré:

#!/bin/bash
for user in $(cut -f1 -d: /etc/passwd)
do echo $user && crontab -u $user -l
echo " "
done

getent passwd | cut -d: -f1 | perl -e'while(<>){chomp;$l = `crontab -u $_ -l 2>/dev/null`;print "$_\n$l\n" if $l}'

Cela évite de jouer directement avec passwd, ignore les utilisateurs qui n'ont pas d'entrées cron et pour ceux qui les ont, il imprime le nom d'utilisateur ainsi que leur crontab.

La plupart du temps, je le laisse ici pour que je puisse le trouver plus tard au cas où j'aurais besoin de le rechercher à nouveau.

Si vous vérifiez un cluster à l'aide de NIS, la seule façon de voir si un utilisateur a une entrée crontab selon la réponse / var / spool / cron / tab de Matt.

grep -v "#" -R  /var/spool/cron/tabs

Pour obtenir la liste des utilisateurs ROOT.

for user in $(cut -f1 -d: /etc/passwd); do echo $user; sudo crontab -u $user -l; done

Ce script a fonctionné pour moi dans CentOS pour répertorier tous les crons de l'environnement:

sudo cat /etc/passwd | sed 's/^\([^:]*\):.*$/sudo crontab -u \1 -l 2>\&1/' | grep -v "no crontab for" | sh

J'aime la réponse simple à une ligne ci-dessus:

pour l'utilisateur dans $ (cut -f1 -d: / etc / passwd); do crontab -u $ user -l; terminé

Mais Solaris qui n'a pas l'indicateur -u et n'imprime pas l'utilisateur qu'il vérifie, vous pouvez le modifier comme suit:

for user in $(cut -f1 -d: /etc/passwd); do echo User:$user; crontab -l $user 2>&1 | grep -v crontab; done

Vous obtiendrez une liste d'utilisateurs sans les erreurs générées par crontab lorsqu'un compte n'est pas autorisé à utiliser cron, etc. Soyez conscient que dans Solaris, les rôles peuvent également se trouver dans / etc / passwd (voir / etc / user_attr).

for user in $(cut -f1 -d: /etc/passwd); 
do 
    echo $user; crontab -u $user -l; 
done

Les éléments suivants suppriment les commentaires, les lignes vides et les erreurs des utilisateurs sans crontab. Il ne vous reste qu'une liste claire des utilisateurs et de leurs tâches.

Notez l'utilisation de sudodans la 2ème ligne. Si vous êtes déjà root, supprimez-le.

for USER in $(cut -f1 -d: /etc/passwd); do \
USERTAB="$(sudo crontab -u "$USER" -l 2>&1)";  \
FILTERED="$(echo "$USERTAB"| grep -vE '^#|^$|no crontab for|cannot use this program')";  \
if ! test -z "$FILTERED"; then  \
echo "# ------ $(tput bold)$USER$(tput sgr0) ------";  \
echo "$FILTERED";  \
echo "";  \
fi;  \
done

Exemple de sortie:

# ------ root ------
0 */6 * * * /usr/local/bin/disk-space-notify.sh
45 3 * * * /opt/mysql-backups/mysql-backups.sh
5 7 * * * /usr/local/bin/certbot-auto renew --quiet --no-self-upgrade

# ------ sammy ------
55 * * * * wget -O - -q -t 1 https://www.example.com/cron.php > /dev/null

Je l'utilise sur Ubuntu (12 à 16) et Red Hat (5 à 7).

Cela dépend de votre version de cron. En utilisant Vixie cron sur FreeBSD, je peux faire quelque chose comme ceci:

(cd /var/cron/tabs && grep -vH ^# *) 

si je veux supprimer plus d'onglets, je pourrais faire quelque chose comme ceci:

(cd /var/cron/tabs && grep -vH ^# * | sed "s/:/      /")

Où c'est un onglet littéral dans la partie de remplacement sed.

Il peut être plus indépendant du système de parcourir les utilisateurs /etc/passwdet de le faire crontab -l -u $userpour chacun d'eux.

Merci pour ce script très utile. J'ai eu de petits problèmes à l'exécuter sur d'anciens systèmes (Red Hat Enterprise 3, qui gèrent différemment egrep et les onglets dans les chaînes), et d'autres systèmes sans rien dans /etc/cron.d/ (le script s'est alors terminé avec une erreur). Voici donc un patch pour le faire fonctionner dans de tels cas:

2a3,4
> #See:  http://stackoverflow.com/questions/134906/how-do-i-list-all-cron-jobs-for-all-users
>
27c29,30
<         match=$(echo "${line}" | egrep -o 'run-parts (-{1,2}\S+ )*\S+')
---
>         #match=$(echo "${line}" | egrep -o 'run-parts (-{1,2}\S+ )*\S+')
>         match=$(echo "${line}" | egrep -o 'run-parts.*')
51c54,57
< cat "${CRONDIR}"/* | clean_cron_lines >>"${temp}"  # */ <not a comment>
---
> sys_cron_num=$(ls /etc/cron.d | wc -l | awk '{print $1}')
> if [ "$sys_cron_num" != 0 ]; then
>       cat "${CRONDIR}"/* | clean_cron_lines >>"${temp}"  # */ <not a comment>
> fi
67c73
<     sed "1i\mi\th\td\tm\tw\tuser\tcommand" |
---
>     sed "1i\mi${tab}h${tab}d${tab}m${tab}w${tab}user${tab}command" |

Je ne suis pas vraiment sûr que les changements dans le premier egrep soient une bonne idée, mais bon, ce script a été testé sans problème sur RHEL3,4,5 et Debian5. J'espère que cela t'aides!

Construire au sommet de @Kyle

for user in $(tail -n +11 /etc/passwd | cut -f1 -d:); do echo $user; crontab -u $user -l; done

pour éviter les commentaires généralement en haut de / etc / passwd,

Et sur macosx

for user in $(dscl . -list /users | cut -f1 -d:); do echo $user; crontab -u $user -l; done    

Je pense qu'une meilleure doublure serait en dessous. Par exemple, si vous avez des utilisateurs dans NIS ou LDAP, ils ne se trouveront pas dans / etc / passwd. Cela vous donnera les crontabs de chaque utilisateur qui s'est connecté.

for I in `lastlog | grep -v Never | cut -f1 -d' '`; do echo $I ; crontab -l -u $I ; done

vous pouvez écrire pour toutes les listes d'utilisateurs:

sudo crontab -u userName -l

,

Vous pouvez aussi aller sur

cd /etc/cron.daily/
ls -l
cat filename

ce fichier listera les horaires

cd /etc/cron.d/
ls -l
cat filename

Toutes mes excuses et merci au yukondude.

J'ai essayé de résumer les paramètres de synchronisation pour une lecture facile, bien que ce ne soit pas un travail parfait, et je ne touche pas `` tous les vendredis '' ou `` uniquement le lundi ''.

Ceci est la version 10 - maintenant:

• fonctionne beaucoup plus rapidement
• a des caractères de progression en option afin que vous puissiez améliorer encore la vitesse.
• utilise une ligne de séparation pour séparer l'en-tête et la sortie.
• sorties dans un format compact lorsque tous les intervalles de synchronisation rencontrés peuvent être résumés.
• Accepte les descripteurs Jan ... Dec pour les mois de l'année
• Accepte les descripteurs Lun ... Sun pour les jours de la semaine
• essaie de gérer le faux anacron de style Debian quand il est manquant
• essaie de traiter les lignes crontab qui exécutent un fichier après avoir testé l'exécutabilité en utilisant "[-x ...]"
• essaie de gérer les lignes crontab qui exécutent un fichier après avoir testé l'exécutabilité en utilisant "command -v"
• permet l'utilisation de plages d'intervalles et de listes.
• prend en charge l'utilisation de run-parts dans les fichiers crontab / var / spool spécifiques à l'utilisateur.

Je publie maintenant le script en entier ici.

https://gist.github.com/myshkin-uk/d667116d3e2d689f23f18f6cd3c71107

Puisqu'il s'agit de parcourir un fichier ( /etc/passwd) et d'effectuer une action, je manque l'approche appropriée sur Comment puis-je lire un fichier (flux de données, variable) ligne par ligne (et / ou champ par champ )? :

while IFS=":" read -r user _
do
   echo "crontab for user ${user}:"
   crontab -u "$user" -l
done < /etc/passwd

Cela lit /etc/passwdligne par ligne en utilisant :comme délimiteur de champ. En disant read -r user _, on fait $usertenir le premier champ et_ le reste (c'est juste une variable indésirable pour ignorer les champs).

De cette façon, nous pouvons alors appeler en crontab -uutilisant la variable $user, que nous citons pour la sécurité (que faire si elle contient des espaces? C'est peu probable dans un tel fichier, mais vous ne pouvez jamais le savoir).

Sous Solaris, pour un nom d'utilisateur connu particulier:

crontab -l username

Tous les autres * Nix auront besoin d'un -umodificateur:

crontab -u username -l

Pour obtenir simultanément tous les travaux des utilisateurs sur Solaris, un peu comme les autres publications ci-dessus:

for user in $(cut -f1 -d: /etc/passwd); do crontab -l $user 2>/dev/null; done

Pour moi, regarder / var / spool / cron / crontabs est la meilleure façon

Ce script génère la Crontab dans un fichier et répertorie également tous les utilisateurs confirmant ceux qui n'ont pas d'entrée crontab:

for user in $(cut -f1 -d: /etc/passwd); do 
  echo $user >> crontab.bak
  echo "" >> crontab.bak
  crontab -u $user -l >> crontab.bak 2>> > crontab.bak
done