unix - manualmente - eliminar crontab linux

¿Cómo enumero todos los trabajos cron para todos los usuarios?

Question

¿Hay un comando o un script existente que me permita ver todos los trabajos cron programados de un sistema * NIX a la vez? Me gustaría incluir todos los crontabs de usuario, así como /etc/crontab , y lo que sea en /etc/cron.d . También sería bueno ver los comandos específicos ejecutados por run-parts en /etc/crontab .

Idealmente, me gustaría la salida en forma de columna agradable y ordenada de alguna manera significativa.

Luego podría combinar estas listas de varios servidores para ver el "calendario de eventos" general.

Estaba a punto de escribir un guión así, pero si alguien ya se ha metido en problemas ...

Answer 1

Construyendo encima de @Kyle

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

para evitar los comentarios generalmente en la parte superior de / etc / passwd,

Y en macosx

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

Answer 2

Creo que un mejor forro estaría por debajo. Por ejemplo, si tiene usuarios en NIS o LDAP, no estarán en / etc / passwd. Esto le dará los crontabs de cada usuario que ha iniciado sesión.

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

Answer 3

Depende de tu versión de cron. Usando Vixie cron en FreeBSD, puedo hacer algo como esto:

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

Si quiero que se elimine más la pestaña, podría hacer algo como esto:

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

Donde hay una pestaña literal en la parte de reemplazo de sed.

Puede ser más independiente del sistema recorrer los usuarios en /etc/passwd y hacer crontab -l -u $user para cada uno de ellos.

Answer 4

Depende de tu versión de linux pero uso:

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

como raíz Muy simple y muy corto.

Me da salida como:

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

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

Answer 5

En Solaris, para un nombre de usuario conocido en particular:

crontab -l username

Todos los demás * Nix necesitarán -u modificador:

crontab -u username -l

Para obtener todos los trabajos de los usuarios a la vez en Solaris, al igual que otras publicaciones anteriores:

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

Answer 6

En Ubuntu o Debian, puede ver crontab por /var/spool/cron/crontabs/ y luego hay un archivo para cada usuario allí. Eso es solo para crontab''s específico del usuario, por supuesto.

Answer 7

Este script envía el Crontab a un archivo y también enumera a todos los usuarios que confirman aquellos que no tienen entrada de 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

Answer 8

Este script me funcionó en CentOS para enumerar todos los crons en el entorno:

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

Answer 9

Esto mostrará todas las entradas de crontab de todos los usuarios.

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

Answer 10

Gracias por este script muy útil. Tuve algunos pequeños problemas al ejecutarlo en sistemas antiguos (Red Hat Enterprise 3, que maneja diferentemente egrep y pestañas en cadenas), y otros sistemas sin nada en /etc/cron.d/ (la secuencia de comandos terminó con un error). Así que aquí hay un parche para que funcione en tales casos:

2a3,4
> #See:  http://.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" |

No estoy realmente seguro de que los cambios en el primer egrep sean una buena idea, pero bueno, este script se ha probado en RHEL3,4,5 y Debian5 sin ningún problema. ¡Espero que esto ayude!

Answer 11

Lo siguiente elimina los comentarios, las líneas vacías y los errores de los usuarios sin crontab. Todo lo que te queda es una lista clara de los usuarios y sus trabajos.

Tenga en cuenta el uso de sudo en la segunda línea. Si ya eres root, quita eso.

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

Ejemplo de salida:

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

Lo uso en Ubuntu (12 a 16) y Red Hat (5 a 7).

Answer 12

Me gusta la respuesta simple de una sola línea anterior:

para el usuario en $ (cortar -f1 -d: / etc / passwd); hacer crontab -u $ usuario -l; hecho

Pero Solaris, que no tiene el indicador -u y no imprime el usuario que está verificando, puede modificarlo así:

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

Obtendrá una lista de usuarios sin los errores generados por crontab cuando una cuenta no tiene permiso para utilizar cron, etc. Tenga en cuenta que en Solaris, los roles también pueden estar en / etc / passwd (consulte / etc / user_attr).

Answer 13

Para mí, ver / var / spool / cron / crontabs es la mejor manera

Answer 14

Para obtener la lista de usuario ROOT.

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

Answer 15

Puedes escribir para todas las listas de usuarios:

sudo crontab -u userName -l

,

También puedes ir a

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

este archivo listará los horarios

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

Answer 16

Si selecciona un clúster utilizando NIS, la única forma de ver si un usuario tiene una entrada crontab es según la respuesta de Matt / var / spool / cron / tabs.

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

Answer 17

Tendrías que ejecutar esto como root, pero:

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

pasará sobre cada nombre de usuario enumerando su crontab. Los crontabs son propiedad de los respectivos usuarios, por lo que no podrá ver el crontab de otro usuario sin ser ellos o root.

Edite si desea saber a qué usuario pertenece un crontab, use echo $user

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

Answer 18

Terminé escribiendo un guión (estoy tratando de enseñarme los puntos más finos de las secuencias de comandos de bash, por eso es que no ves algo como Perl aquí). No es exactamente un asunto simple, pero hace la mayor parte de lo que necesito. Utiliza la sugerencia de Kyle para buscar crontabs de usuarios individuales, pero también trata con /etc/crontab (incluidos los scripts lanzados por run-parts en /etc/cron.hourly , /etc/cron.daily , etc.) y los trabajos en el directorio /etc/cron.d Toma todos esos y los combina en una pantalla como la siguiente:

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

Tenga en cuenta que muestra al usuario, y más o menos ordenados por hora y minuto para que pueda ver el programa diario.

Hasta ahora, lo he probado en Ubuntu, Debian y 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}"

Answer 19

Un pequeño refinamiento de la respuesta de Kyle Burton con un formato de salida mejorado:

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

Answer 20

Ya que se trata de hacer un bucle a través de un archivo ( /etc/passwd ) y realizar una acción, me falta el enfoque adecuado sobre ¿Cómo puedo leer un archivo (flujo de datos, variable) línea por línea (y / o campo)? -por campo)? :

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

Esto lee línea /etc/passwd línea /etc/passwd usando : como delimitador de campo. Al decir read -r user _ , hacemos que $user mantenga el primer campo y _ el resto (es solo una variable de correo no deseado para ignorar los campos).

De esta manera, podemos llamar a crontab -u usando la variable $user , que cotizamos por seguridad (¿qué sucede si contiene espacios? Es poco probable que se encuentre en dicho archivo, pero nunca se puede saber).

Answer 21

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

Answer 22

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

Esto evita que se ensucie con passwd directamente, omite a los usuarios que no tienen entradas de cron y para aquellos que las tienen, imprime el nombre de usuario y su crontab.

Aunque solté esto principalmente aquí, así podré encontrarlo más tarde en caso de que necesite buscarlo nuevamente.