# rm-rf.es

El comando crontab nos permite añadir, eliminar o modificar los cron configurados para un usuario de una máquina Unix.

El modo de uso es el siguiente: crontab -<opciones>, a continuación os muestro unos ejemplos:

Editar los cron del usuario “alex”:

crontab -e -u alex

Listar los cron del usuario “alex”:

crontab -l -u alex

Eliminar los cron del usuario alex:

crontab -r -u alex

En todos estos casos, si omitimos “-u alex” accederemos a los cron del usuario con el que estemos identificados en el sistema. Una vez dentro de la gestión de crontab (si estamos editando con -e” visualizaremos todos los cron configurados para el usuario, ejemplo:

Nota: Automáticamente accederéis a la gestión de los cron con el editor que haya configurado por defecto, si queréis modificarlo revisad esta entrada: Cambiar editor crontab por defecto)

$ crontab -e -u alex

0 * * * * /usr/sbin/ntpdate hora.oxixares.com > /dev/null
0 20 * * * echo "Me ejecuto a las ocho en punto" > /dev/null

Crontab pone a nuestra disposición 6 campos cuyo significado es el siguiente (en orden, de izquierda a derecha) :

1. Minuto (0-59)
2. Hora (0-23)
3. Día del mes (1-31)
4. Mes del año (1-12)
5. Día de la semana (0-7, 0 y 7 es Domingo)
6. Comando/Script/tarea a ejecutar

En los 5 primeros campos podemos usar Wildcard (*), para especificar que se ejecutará en cualquiera de las opciones de ese campo (si son horas todas las horas, si son días todos los días, etc).

En el primer ejemplo que he mostrado antes, cada hora en punto ejecutamos la sincronización horaria y mandamos la salida a /dev/null/:

0 * * * * /usr/sbin/ntpdate hora.oxixares.com > /dev/null

En el segundo ejemplo, simplemente escribimos la frase a las 20:00 todos los días:

0 20 * * * echo "Me ejecuto a las ocho en punto" > /dev/null

Al comienzo del fichero podemos especificar una dirección de correo electrónico a la cual se envíen los informes de ejecución de crontabs:

MAILTO="test@test.com"

Con estas nociones básicas ya podéis trabajar de un modo eficaz gestionando cron mediante el comando crontab.

Para apagar o reiniciar una máquina Windows de forma remota, y desde un equipo Linux lo primero que tenemos que hacer es tener instalado el paquete samba-common, que contiene herramientas y ficheros que se utilizan para la comunicación entre el cliente y servidor Samba.

En sistemas Debian lo instalaremos del siguiente modo:

sudo apt-get install samba-common

Y en sistemas RHEL / CentOS:

yum install samba-common

Una vez instalado el paquete, podremos hacer uso del comando “net rpc” (revisad la documentación de net porque tiene muchas más posibilidades) para reiniciar o apagar un servidor Windows de forma remota.

Apagar un servidor Windows desde Linux:

net rpc shutdown -I IP_SERVIDOR_WINDOWS -U usuario%password

Reiniciar un servidor Windows desde Linux:

net rpc shutdown -r IP_SERVIDOR_WINDOWS -U usuario%password

Hay que tener en cuenta que el usuario que utilicéis para realizar estas tareas debe encontrarse dentro del grupo administradores de la máquina Windows. Si tenéis pensado administrar en mayor o menor medida equipos Windows desde Linux os recomiendo revisar todas las demás opciones de net.

Por defecto, rsync no elimina los ficheros antiguos en el servidor de destino de la copia. Esto implica que pese a que haya ficheros en el sistema del que estamos haciendo copias de seguridad que ya han sido eliminados, permanecerán por siempre en el sistema de copias de seguridad (destino) a no ser que los eliminemos manualmente.

Las opciones para forzar que cada vez que ejecutemos rsync también se eliminen en el destino ficheros y carpetas que ya no existen en el origen son las siguientes:

     --del                   an alias for --delete-during
     --delete                delete extraneous files from destination dirs
     --delete-before         receiver deletes before transfer (default)
     --delete-during         receiver deletes during transfer, not before
     --delete-after          receiver deletes after transfer, not before
     --delete-excluded       also delete excluded files from destination dirs
     --ignore-errors         delete even if there are I/O errors
     --force                 force deletion of directories even if not empty
     --max-delete=NUM        don't delete more than NUM files

La opción más básica es –delete, aunque podemos personalizar aún más y elegir si deseamos que los ficheros a borrar se eliminen antes de la transferencia de ficheros (–delete-before, es lo mismo que –delete), después (-delete-after) o durante (–delete-during). Además de esto podemos elegir si ignorar errores y borrar pese a fallos de I/O, forzar eliminación de directorios no vacíos, etc.

Ejemplo de rsync con sincronización y borrado de archivos:

Es imposible conocer todos los comandos que nos ofrece cualquier shell, para solucionar este “problema” existen herramientas que nos hacen la vida más fácil, una de ellas es el comando apropos.

Apropos es un comando que busca dentro de las descripciones de cada una de las páginas man las palabras claves que le indiquemos pasandolas como argumentos. Estas palabras claves pueden contener comodines o ser la palabra clave exacta.

Por ejemplo, si quisieramos buscar comandos que sirven para copiar ficheros podríamos hacerlo del siguiente modo (suponiendo un sistema en idioma inglés):

$ apropos "copy files"
cp (1)               - copy files and directories
cpio (1)             - copy files to and from archives
install (1)          - copy files and set attributes

Como véis nos muestra tres comandos que pueden servirnos para realizar operaciones de copiado de ficheros. Otro ejemplo podría ser la búsqueda de un comando/programa para gestionar particiones:

$ apropos "partition"
addpart (8)          - simple wrapper around the "add partition" ioctl
cfdisk (8)           - Curses/slang based disk partition table manipulator for Linux
delpart (8)          - simple wrapper around the "del partition" ioctl
fdisk (8)            - Partition table manipulator for Linux
iostat (1)           - Report Central Processing Unit (CPU) statistics and input/output statistics for devices, partitions an...
mpartition (1)       - partition an MSDOS hard disk
partprobe (8)        - inform the OS of partition table changes
partx (8)            - telling the kernel about presence and numbering of on-disk partitions.
sfdisk (8)           - Partition table manipulator for Linux

Como véis es un comando muy útil en situaciones que no conocemos un comando para realizar una determinada tarea.

Con estas dos secuencias de comandos podréis ver de un modo rápido y sencillo los procesos ordenados por uso (%) de CPU y memoria. Por supuesto no es necesario (ni práctico) escribir el comando completo en la shell cada vez que lo queráis ejecutar, os recomiendo crear un alias específico para cada uno de ellos.

Listar procesos por % cpu, veréis que eliminamos aquellos que usan 0.0 de CPU con sed (sed ‘/^ 0.0 /d):

ps -e -o pcpu,cpu,nice,state,cputime,args --sort pcpu | sed '/^ 0.0 /d'

Ejemplo:

$ ps -e -o pcpu,cpu,nice,state,cputime,args --sort pcpu | sed '/^ 0.0 /d'
%CPU CPU  NI S     TIME COMMAND
0.2   -   0 S 00:00:24 metacity
0.2   -   0 S 00:00:00 /usr/bin/python /usr/bin/terminator
0.2   -   0 S 00:00:28 gnome-screensaver
0.2   -   0 S 00:00:31 gnome-panel
4.6   -   0 S 00:08:23 /usr/bin/pulseaudio --start
7.4   -   0 S 00:13:24 /usr/X11R6/bin/X :0 -br -audit 0 -auth /var/lib/gdm/:0.Xauth -nolisten tcp vt7
7.5   -   0 S 00:04:31 rhythmbox
14.4   -   0 S 00:08:50 /usr/lib/firefox-3.5.4/firefox-3.5

Listar procesos por uso de memoria (en KB):

ps -e -orss=,args= | sort -b -k1,1n | pr -TW$COLUMNS

Ejemplo (reducido):

$ ps -e -orss=,args= | sort -b -k1,1n | pr -TW$COLUMNS
23964 gnome-panel
26168 nautilus
26256 /usr/bin/python /usr/bin/terminator
58340 /usr/X11R6/bin/X :0 -br -audit 0 -auth /var/lib/gdm/:0.Xauth -nolisten tcp vt7
58728 rhythmbox
128736 /usr/lib/firefox-3.5.4/firefox-3.5

Encontrado en pixelbeat

Hoy os dejo un pequeño truco para los que uséis wget para descargar ficheros desde la línea de comandos. Este tip sirve para limitar la velocidad de descarga, de modo que si no queréis saturar la conexión a Internet descargando un fichero podáis hacerlo:

En el siguiente ejemplo vamos a poner una limitación de 200k para la descarga de un fichero:

wget --limit-rate=200k http://test.com/fichero.rar

En Linux, gracias al comando “time“, podemos saber el tiempo que tarda en ejecutarse un determinado comando. La sintaxis es sencilla:

time comando

Por supuesto podemos asignar al comando unas cuantas opciones, como por ejemplo guardar las estadísticas en un fichero en vez de mostrarlas por pantalla, formatear la string que muestra el resultado del tiempo, etc. Para ello revisad la página man (man time) y veréis todas las posibilidades que ofrece.

Unos ejemplos:

Cambiar el propietario y grupo de la carpeta “test” y mostrar el tiempo que ha costado ejecutarlo:

$ time chown -R alex. test/

real	0m0.058s
user	0m0.012s
sys	0m0.048s

Como véis muestra el tiempo total de ejecución, y el que ha sido empleado por el usuario y el sistema.

Mostrar el tamaño ocupado por la carpeta “Peliculas” y el tiempo que ha costado sacarlo:

$ time du -shc Peliculas/
12G	Peliculas/
12G	total

real	0m0.007s
user	0m0.000s
sys	0m0.008s

Antes de conocer el comando watch de Linux, si por ejemplo quería revisar cada pocos segundos las consultas MySQL que se estaban ejecutando en una máquina, tenía que estar continuamente ejecutando el comando en la terminal para ver la salida del mismo:

# mysqladmin processlist -u root -pxxxx
+--------+-----------+-----------+-------+---------+-------+-------+------------------+
| Id     | User      | Host      | db    | Command | Time  | State | Info             |
+--------+-----------+-----------+-------+---------+-------+-------+------------------+
| 205709 | root      | localhost |       | Query   | 0     |       | show processlist |
+--------+-----------+-----------+-------+---------+-------+-------+------------------+

# mysqladmin processlist -u root -pxxxx
+--------+-----------+-----------+-------+---------+-------+-------+------------------+
| Id     | User      | Host      | db    | Command | Time  | State | Info             |
+--------+-----------+-----------+-------+---------+-------+-------+------------------+
| 205709 | root      | localhost |       | Query   | 0     |       | show processlist |
+--------+-----------+-----------+-------+---------+-------+-------+------------------+

# mysqladmin processlist -u root -pxxxx
+--------+-----------+-----------+-------+---------+-------+-------+------------------+
| Id     | User      | Host      | db    | Command | Time  | State | Info             |
+--------+-----------+-----------+-------+---------+-------+-------+------------------+
| 205709 | root      | localhost |       | Query   | 0     |       | show processlist |
+--------+-----------+-----------+-------+---------+-------+-------+------------------+

Esta lógicamente no es la forma óptima de realizar la tarea. En el momento que necesitamos supervisar la salida de un comando periódicamente o ejecutarlo, lo mejor es utilizar “watch”. Watch es un comando que permite especificar un intervalo de tiempo, que será el que especificará cada cuanto ejecutaremos el comando que pasamos como argumento.

Si quisiera ejecutar el comando anterior cada 4 segundos y ver su salida por pantalla, podría hacerlo del siguiente modo:

# watch -n 4 'mysqladmin processlist -u root -pxxxx'

Y automáticamente vería lo siguiente, que refrescaría cada 4 segundos (el intervalo de segundos se especifica con la opción -n , por defecto 2 segundos):

Every 4,0s: mysqladmin processlist -u root -pxxxxx                                         Sat Oct 24 19:14:27 2009

+--------+-----------+-----------+-------+---------+-------+-------+------------------+
| Id     | User      | Host	 | db    | Command | Time  | State | Info             |
+--------+-----------+-----------+-------+---------+-------+-------+------------------+
| 205717 | root      | localhost |	 | Query   | 0     |	   | show processlist |
+--------+-----------+-----------+-------+---------+-------+-------+------------------+

A partir de aquí ya podéis encontrarle muchas más utilidades, como por ejemplo ver cada 2 segundos la memoria utilizada:

# watch free -m

O ver como cambia el contenido de una carpeta en concreto:

# watch -d ls -l 

En definitiva, un excelente comando que puede resultar de gran utilidad en el día a día.