En Linux y Unix existen otros comandos además de top para monitorizar de un modo eficiente la utilización de las CPU en el sistema. Hoy vamos a ver unos cuantos ejemplos del comando sar. En este primer artículo nos centramos en la CPU, veremos en sucesivos que podemos ir más allá (disco, red, procesos, carga, etc).

Para poder comenzar a utilizar sar, debemos tener en cuenta que es necesario por un lado tener corriendo el proceso sysstat:

# /etc/init.d/sysstat start
# chkconfig sysstat on

Además, hay que configurar sysstat para permitir la recolección de datos. Estos datos estadísticos se almacenan en /var/log/sysstat/sa*. Para ello es necesario tener estos parámetros en el fichero de configuración /etc/sysconfig/sysstat. Lo hacemos antes de reiniciar sysstat:

ENABLED="false"
SA1_OPTIONS="-S DISK"

Normalmente, si se instala el paquete por yum o apt, automáticamente se configuran los cron necesarios para recolectar la información que utiliza sar:

$ more /etc/cron.d/sysstat
# Global variables:
#
#  our configuration file
DEFAULT=/etc/default/sysstat
#  default setting, overriden in the above file
ENABLED=false
SA1_OPTIONS=""

# Activity reports every 10 minutes everyday
5-55/10 * * * * root [ -x /usr/lib/sysstat/sa1 ] && { [ -r "$DEFAULT" ] && . "$DEFAULT" ; [ "$ENABLED" = "true" ] && exec /usr/lib/sysstat/
sa1 $SA1_OPTIONS 1 1 ; }

# Additional run at 23:59 to rotate the statistics file
59 23 * * * root [ -x /usr/lib/sysstat/sa1 ] && { [ -r "$DEFAULT" ] && . "$DEFAULT" ; [ "$ENABLED" = "true" ] && exec /usr/lib/sysstat/sa1
$SA1_OPTIONS 60 2 ; }

Vamos a ver unos cuantos ejemplos, os recomiendo como siempre revisar la página man porque es un comando con mucho potencial y opciones.

Mostrar el uso de CPU en un intervalo de tiempo determinado

El siguiente ejemplo muestra el uso de cpu cada 2 segundo:

# sar -u 2
Linux 2.6.28-17-generic (sistemas) 	22/01/12 	_i686_	(2 CPU)

19:14:05        CPU     %user     %nice   %system   %iowait    %steal     %idle
19:14:07        all     12,08      0,00      3,86      0,72      0,00     83,33
19:14:09        all      8,52      0,00      2,19      0,00      0,00     89,29
19:14:11        all      8,39      0,00      2,88      0,72      0,00     88,01
...
...
...

EL siguiente ejemplo hace lo mismo a excepción de que se ejecutará únicamente 4 veces. El anterior por contra se ejecutaba continuamente hasta que lo cancelaramos. Lo interesante de este ejemplo es que al final nos muestra una media de utilización durante el tiempo que se ha ejecutado:

# sar -u 2 4
Linux 2.6.28-17-generic (sistemas) 	22/01/12 	_i686_	(2 CPU)

19:16:39        CPU     %user     %nice   %system   %iowait    %steal     %idle
19:16:41        all     35,47      0,00      6,40      3,20      0,00     54,93
19:16:43        all     26,57      0,00     10,78      0,00      0,00     62,66
19:16:45        all     13,87      0,00      3,65      1,46      0,00     81,02
19:16:47        all     19,07      0,00      5,13      0,00      0,00     75,79
Media: all 23,69 0,00 6,46 1,17 0,00 68,68

Para los que no conozcáis el significado de cada columna:

• CPU: CPUs que se stán monitorizando, en los casos anteriores todas las del equipo.
• %user:  Porcentaje de tiempo de CPU utilizada por aplicaciones/procesos a nivel de usuario.
• %nice:  Porcentaje de tiempo de CPU utilizada por aplicaciones/procesos con prioridad nice asignada.
• %system:  Porcentaje de tiempo de CPU utilizada por aplicaciones/procesos a nivel de sistema/kernel.
• %iowait:  Porcentaje de tiempo de CPU en espera a que terminen operaciones de I/O.
• %steal:  Porcentaje de tiempo utilizado por las CPU en involuntary wait mientras el hypervisor servía a otro procesador virtual
• %idle: Porcentaje de tiempo de CPU en espera y sin operaciones de I/O pendientes.

Por supuesto se pueden añadir más columnas, revisad las páginas man:

# sar -u ALL 2 4
Linux 2.6.28-17-generic (sistemas) 	22/01/12 	_i686_	(2 CPU)

19:28:16        CPU      %usr     %nice      %sys   %iowait    %steal      %irq     %soft    %guest     %idle
19:28:18        all      9,18      0,00      2,90      0,97      0,00      0,00      0,00      0,00     86,96
19:28:20        all      7,95      0,00      4,34      0,00      0,00      0,00      0,00      0,00     87,71
19:28:22        all     14,46      0,00      5,15      1,47      0,00      0,25      0,00      0,00     78,68
19:28:24        all     17,89      0,00      5,39      0,00      0,00      0,00      0,00      0,00     76,72
Media:          all     12,34      0,00      4,44      0,61      0,00      0,06      0,00      0,00     82,55

Si ejecutaramos sar -u sin parámeteros nos mostaría la CPU utilizada durante el día, sacándola de los ficheros de estadísticas.

Monitorizar por CPU

En lugar de mostrar el estado de todas las CPU a la vez podemos seleccionar la que queramos o incluso mostrar una fila para cada CPU de forma independiente. En el siguiente ejemplo monitorizamos la CPU 1 durante 2 segundos y cuatro ejecuciones:

$ sar -P 1 2 4
Linux 2.6.28-17-generic (sistemas) 	22/01/12 	_i686_	(2 CPU)

19:29:17        CPU     %user     %nice   %system   %iowait    %steal     %idle
19:29:19          1     22,49      0,00      2,39      0,48      0,00     74,64
19:29:21          1      3,33      0,00      2,86      0,00      0,00     93,81
19:29:23          1     17,92      0,00      5,19      0,00      0,00     76,89
19:29:25          1     26,09      0,00     14,01      0,00      0,00     59,90
Media:            1     17,42      0,00      6,09      0,12      0,00     76,37

Como decía antes, una fila para cada CPU, en este caso un equipo con 2 CPU, únicamente una ejecución:

$ sar -P ALL 2 1
Linux 2.6.28-17-generic (sistemas) 	22/01/12 	_i686_	(2 CPU)

19:31:12        CPU     %user     %nice   %system   %iowait    %steal     %idle
19:31:14        all     17,69      0,00      3,93      0,74      0,00     77,64
19:31:14          0     22,39      0,00      2,99      0,00      0,00     74,63
19:31:14          1     13,04      0,00      5,31      1,45      0,00     80,19

Media:          CPU     %user     %nice   %system   %iowait    %steal     %idle
Media:          all     17,69      0,00      3,93      0,74      0,00     77,64
Media:            0     22,39      0,00      2,99      0,00      0,00     74,63
Media:            1     13,04      0,00      5,31      1,45      0,00     80,19

Mostrar toda la información almacenada en el fichero de estadísticas diario

$ sar -A

Sar no se limita únicamente a la monitorización de CPU, también podemos controlar la actividad en discos (al estilo iostat), de red, procesos, load average, etc. En este primer artículo no hemos centrado en la CPU, en los próximos veremos algunos ejemplos de ello.

En algunas versiones del comando mail|mailx|Mail (creo que en las antiguas) se podía especificar una cabecera con el parámetro -a:

$ mail --help
usage: mail [-dEIinv] [-a header] [-b bcc-addr] [-c cc-addr] [-s subject] to-addr ...

De este modo era sencillo especificar cualquier cabecera y modificarla, como por ejemplo el Content-type si quisieramos enviar un correo en formato HTML (text/html). En cambio en nuevas versiones este parámetro ha desaparecido, y si queremos añadir el Content-type, por ejemplo, hay que engañar al MTA del siguiente modo:

$ cat mensaje.html | mail -s "$(echo -e "Este es el asunto\nContent-Type: text/html")" foo@bar.com

Como véis, a la hora de especificar el subject del mail con el parámetro -s, hacemos la trampa de crear un salto de línea y especificar después el Content-type, al igual que podemos ver en las cabeceras de un email estándar. De este modo, el MTA no asocia la segunda línea con el Subject sino como si fuera una cabecera normal de Content Type.

Grep es sin duda alguna no de los comandos más utilizados en el día a día por los administradores de sistemas. Muchos no van más allá de sus usos más básicos, que si bien cumplen a la perfección su función son una mínima parte de las posibilidades que nos ofrece. Algunos de estos ejemplos se pueden ejecutar tanto con grep como con egrep (egrep= grep -E), independientemente de que casi siempre se ejecuten con egrep en el post. Espero que os sean de utilidad.

Este es el texto que se va a utilizar para trabajar como ejemplo. Sí, es un fichero de configuración de un Cluster MySQL de prueba, pero es que no tenía otra cosa a mano y no me apetecía preparar un fichero específicamente para esto ;)

[ndb_mgmd]
hostname=192.168.0.10           # Hostname or IP address of management node
datadir=/var/lib/mysql-cluster  # Directory for management node log files

# Options for data node "A":
[ndbd]
                                # (one [ndbd] section per data node)
hostname=192.168.0.30           # Hostname or IP address
datadir=/usr/local/mysql/data   # Directory for this data node's data files

# Options for data node "B":
[ndbd]
hostname=192.168.0.40           # Hostname or IP address
datadir=/usr/local/mysql/data   # Directory for this data node's data files

# SQL node options:
[mysqld]
hostname=192.168.0.20           # Hostname or IP address
                                # (additional mysqld connections can be
                                # specified for this node for various
                                # purposes such as running ndb_restore)

Buscar dos ó n strings distintas dentro de un mismo fichero

La sintaxis es ‘(cadena1|cadena2|cadenaN)’. La salida será todas aquellas líneas que contienen cualquiera de esas strings. Esto nos permite hacer múltiples búsquedas en un único comando:

$ egrep '(192.168.0.30|192.168.0.40)' test
hostname=192.168.0.30           # Hostname or IP address
hostname=192.168.0.40           # Hostname or IP address

$ egrep '(192.168.0.30|192.168.0.40|192.168.0.20)' test
hostname=192.168.0.30           # Hostname or IP address
hostname=192.168.0.40           # Hostname or IP address
hostname=192.168.0.20           # Hostname or IP address

Usar los corchetes para reducir el rango de búsqueda

Podemos hacer uso de los corchetes [] para definir, dentro de una misma string, que una sección contenga únicamente X carácteres, un rango de ellos, etc.

En este caso queremos sacar únicamente los resultados que contengan 192.168.0.30 y 192.168.0.40:

$ egrep 192.168.0.[30,40] test
hostname=192.168.0.30           # Hostname or IP address
hostname=192.168.0.40           # Hostname or IP address

Pero si quisiéramos definir los rangos que queremos mostrar para los dos últimos caracteres, en este caso numéricos (se podría hacer con alfanuméricos) podemos hacerlo separando el valor inicial y el final con “-”. En este ejemplo queremos que nos muestre aquello que cumpla la condición de que el primer número del último bloque tiene que ser 0,1 ó 2:

$ egrep 192.168.0.[0-2]0 test
hostname=192.168.0.10           # Hostname or IP address of management node
hostname=192.168.0.20           # Hostname or IP address

Y en este que el primer número del último bloque sea 1,2 ó 3 y el último entre 0 y 9:

$ egrep 192.168.0.[0-3][0-9] test
hostname=192.168.0.10           # Hostname or IP address of management node
hostname=192.168.0.30           # Hostname or IP address
hostname=192.168.0.20           # Hostname or IP address

Un ejemplo práctico con caracteres alfanuméricos sería usar por ejemplo [a-c]test, que buscaría atest, btest y ctest ó por ejemplo [ar4d]test que buscaría atest, rtest, 4test y dtest.

Uso de clases predefinidas

Existen clases predefinidas que nos pueden llegar a ahorrar mucho trabajo. Son las siguientes:

[:alnum:], [:alpha:], [:cntrl:], [:digit:], [:graph:], [:lower:], [:print:], [:punct:], [:space:], [:upper:], [:xdigit:]

Lo que hace cada una de ellas está claro por su nombre, no obstante vamos a ver un ejemplo. Podemos buscar toda línea que contenga un carácter en mayúsculas:

$ egrep [[:upper:]] test
hostname=192.168.0.10           # Hostname or IP address of management node
datadir=/var/lib/mysql-cluster  # Directory for management node log files
...
...

Todo lo que comienza o termina por…

Esto es sencillo, las líneas comienzan por el carácter ^ y terminan con $. Por lo que:

Buscar todo lo que comience por “hostname”:

$ egrep ^hostname test
hostname=192.168.0.10           # Hostname or IP address of management node
hostname=192.168.0.30           # Hostname or IP address
hostname=192.168.0.40           # Hostname or IP address
hostname=192.168.0.20           # Hostname or IP address

O todo lo que termine por “node”:

$ egrep node$ test
hostname=192.168.0.10           # Hostname or IP address of management node

Más expresiones regulares

Ya hicimos un artículo sobre ello hace tiempo, podéis revisarlo aquí: unix: Expresiones regulares, ahí también encontraréis unos cuantos ejemplos de grep. Son muy útiles los operadores de repetición:

       ?      El carácter que precede es opcional y coincide al menos una vez.
       *      El carácter que precede coincidirá 0 o más veces.
       +      El carácter que precede coincidirá 1 o más veces.
       {n}    El carácter que precede coincidirá exactamente n veces.
       {n,}   El carácter que precede coincidirá n o más veces.
       {,m}   El carácter que precede coincidirá como máximo m veces.
       {n,m}  El carácter que precede coincidirá entre n y m veces.

Podemos entonces buscar todas las líneas del fichero que contienen una IP. Usamos primero los corchetes para definir que puede haber números del 0 al 9, con las llaves decimos que habrá 1 o 3 números en cada bloque y así cuatro veces (nota: hay que escapar las llaves):

$ grep '[0-9]\{1,3\}.[0-9]\{1,3\}.[0-9]\{1,3\}.[0-9]\{1,3\}' test
hostname=192.168.0.10           # Hostname or IP address of management node
hostname=192.168.0.30           # Hostname or IP address
hostname=192.168.0.40           # Hostname or IP address
hostname=192.168.0.20           # Hostname or IP address

Buscar palabras completas, contar resultados

Para indicar a grep que queremos que la búsqueda se centre en palabras y no en caracteres sueltos especificamos el parámetro “-w”. Podemos ver la diferencia buscando “data” en el ejemplo, contamos los resultados satisfactorios con el parámetro “-c”:

$ grep -cw data test
5
$ grep -c data test
6

Excluir resultados, sensibilidad a mayúsculas

Algo básico a la hora de usar grep es conocer los parámetros “-v” que excluye la cadena indicada en el resultado y “-i” que especifica que no se tendrá en cuenta si el resultado es mayúscula o minúscula.

Eliminamos las líneas que tienen comodines:

$ grep -v "#" test
[ndb_mgmd]

[ndbd]

[ndbd]

[mysqld]

Uso de pipes

Todos usamos pipes (|) para acotar resultados. Hacemos un primer grep, con el resultado de ese hacemos otro y así sucesivamente:

$ grep -iw hostname test | grep 192.168.0.[0-9]0 | grep -v 192.168.0.40 | grep -vw node
hostname=192.168.0.30           # Hostname or IP address
hostname=192.168.0.20           # Hostname or IP address

Listar los archivos que contienen la cadena

Con el parámetro -l podemos ejecutar grep contra varios archivos (y de forma recursiva en múltiples directorios con -R) y recibiremos el listado de archivos con coincidencias sin mostrar las líneas que contienen la cadena:

$ grep -lR SQL *
config.ini
header.xcf
iptables.sh
test
dir1/test.sql
dir2/prueba.txt
...

Número de línea en la que se encuentran los resultados

Para saber el número de línea en la que se encuentra el resultado utilizaremos el parámetro -n:

$ grep -n hostname test
2:hostname=192.168.0.10           # Hostname or IP address of management node
8:hostname=192.168.0.30           # Hostname or IP address
...

Cuantas veces se encuentran resultados

Si “-n” nos monstraba el nº de línea en el que estaba la coincidencia, “-c” nos dice cuantas veces está la búsqueda en el fichero:

$ grep -c hostname test
4

Bueno, de momento esto es todo. Por supuesto hay muchas más opciones y explotar la potencia de grep llevaría mucho tiempo así que a partir de aquí investigáis vosotros ;)

Cuando necesitamos manipular a través de scripts un fichero LDIF, y este tiene líneas de atributos divididas con saltos de línea es necesario revertir esto y volver a concatenarlas para poder comenzar a trabajar. Como muchos sabéis, el estándar de LDIF especifica este punto:

Any line that begins with a single space MUST be treated as a continuation of the previous (non-empty) line. When joining folded lines, exactly one space character at the beginning of each continued line must be discarded. Implementations SHOULD NOT fold lines in the middle of a multi-byte UTF-8 character.

Vamos a ver entonces como a través de una línea de comandos usando sed podemos concatenar de nuevo las líneas que comiencen con un espacio con la línea anterior. El comando es el siguiente:

$ sed -e :a -e '$!N;s/\n //;ta' -e 'P;D' test.ldif

Este ejemplo únicamente volcará la salida por pantalla, recordar redirigir stdout a otro fichero o forzar con “-i” para sobreescribir el mismo fichero.

Pese a que aparentemente su función es la misma, es decir, la de realizar tareas de forma automática y desantendida en momentos concretos y/o periódicos, cada uno tiene sus peculiaridades y características que los hacen bastante distintos y su utilización depende de ámbitos distintos. De cron/crontab ya he hablado en varias ocasiones, no así de anacron, podéis usar el buscador o seguir el anterior enlace para encontrar más artículos.

Básicamente, las principales diferencias entre cron y anacron son las siguientes:

1. Cron es estricto al 100% a la hora de ejecutar tareas configuradas, todo lo contrario que anacron. Si hay un cron que se tiene que ejecutar todos los días a las 03:00 y el sistema está apagado, cron no lo ejecutará. En cambio, anacron sí, lo ejecutará una vez que el sistema vuelva a encenderse si el trabajo tenía que haberse realizado cuando el equipo estaba apagado. Es decir, en servidores y sistemas con disponibilidad 24 x 7 x 365 es mejor usar cron, pero en equipos de escritorio o aquellos que puedan estar apagados es mejor anacron.
2. Cron permite programar tareas con exactitud de minutos, mientras que en anacron el mínimo es la ejecución diaria de la tarea, pudiendo únicamente especificar un rango horario en el que se ejecutará.
3. Cualquier usuario puede tener sus propios cron configurados, mientras que para usar anacron hay que ser superusuario. (cron es versatil y se puede restringir si fuera necesario).
4. Cron corre como demonio todo el tiempo mientras que anacron se ejecuta a través de scripts en el arranque de sistema o con llamadas propias desde cron.

Normalmente en la mayoría de sistemas de producción, por no decir en todos encontraréis que se usa cron, anacron se suele dejar para equipos de escritorio, portátiles y demás equipos de uso personal.

Hoy vamos a dar un repaso al gestor de paquetes de Debian (y Ubuntu…) apt (Advanced Packaging Tool). Nos vamos a centrar en apt-get y apt-cache. apt-get permite descargar, actualizar e instalar paquetes entre otras cosas, apt-cache por otro lado permite lanzar consultas y buscar paquetes contra la base de datos de los repositorios.

APT-GET

Instalar un paquete:

# apt-get install <paquete>

Desinstalar un paquete:

# apt-get remove <paquete>

Eliminar un paquete incluidos sus ficheros de configuración:

# apt-get purge <paquete>

Eliminar de forma automática aquellos paquetes que no se estén utilizando:

# apt-get autoremove

Actualizar un paquete a la última versión disponible en el repositorio:

# apt-get update <paquete>

Actualizar el sistema. Actualizará todos los paquetes que dispongan de una versión superior dentro de la rama instalada de la distribución:

# apt-get upgrade

Actualizar la distribución completa. Actualizará nuestro sistema a la siguiente versión disponible de la distribución:

# apt-get dist-upgrade

Descargar únicamente las fuentes de un paquete para manipularlas de forma manual:

# apt-get source <paquete>

Limpiar cachés, paquetes descargados, etc:

# apt-get clean

# apt-get autoclean

Verificar que no tenemos ninguna dependencia incumplida:

# apt-get check

APT-CACHE

Buscar un paquete en los repositorios, se puede especificar un patrón, expresión regular, el nombre exacto del paquete, etc:

# apt-cache search <paquete>

Mostrar información sobre un paquete específico (nombre del paquete, versión, dependencias…):

# apt-cache showpkg <paquete>

Mostrar información del paquete incluyendo la descripción, información del paquete como su sitio web, página de bugs…

# apt-cache show <paquete>

Mostrar dependencias de un paquete:

# apt-cache depends <paquete>

Mostrar los nombres de todos los paquetes instalados en el sistema:

# apt-cache pkgnames

{} es el marcador por defecto para los argumentos que pasamos al comando xargs. Existe la opción de renombrar este marcador para hacer más comprensible el comando y/o evitar problemas como el que podemos ver a continuación:

# grep xx@xxxx.es /var/log/exim_mainlog | awk '{print $3}' | sort -u | xargs grep {} /var/log/exim_mainlog

grep: 1QmbRA-0003Ba-4E: No such file or directory
grep: 1QmdAR-0001To-DY: No such file or directory
grep: 1QmeHn-0002ZO-Ib: No such file or directory
grep: 1Qmfzd-0008TC-Lc: No such file or directory
grep: 1QmgoV-0002aV-Vo: No such file or directory
grep: 1QmhPk-0000Ou-UV: No such file or directory
grep: 1Qmi22-0007kj-B3: No such file or directory
grep: 1Qmifd-0006ur-3S: No such file or directory

Como podéis ver el argumento, que es el identificador del correo lo recibe correctamente pero genera problemas a la hora de ejecutar el xargs. En casos como estos, si no tenéis tiempo para revisar el problema podéis probar a renombrar {} por una cadena de texto con el parámetro -I y verificar si de ese modo funciona:

# grep xx@xxxx.es /var/log/exim_mainlog | awk '{print $3}' | sort -u | xargs -I marcador grep marcador /var/log/exim_mainlog

011-07-29 16:14:38 1Qmnpl-0000za-U7 H=([XX.XX.XX.230]) [XX.XX.XX.XX]Warning: "SpamAssassin as xx detected message as NOT spam (-0.2)"
2011-07-29 16:14:38 1Qmnpl-0000za-U7  xxx  R=virtual_user T=virtual_userdelivery
2011-07-29 16:14:39 1Qmnpl-0000za-U7 => xx@xx.es  R=lookuphost T=remote_smtp H=xx.xx.es [xx.xx.xx.xx] X=TLSv1:DHE-RSA-AE3256-SHA:256
2011-07-29 16:14:39 1Qmnpl-0000za-U7 Completed

Efectivamente así ha funcionado correctamente.

Tee es un comando Linux (bueno, realmente está disponible en Unix, 4DOS/4NT y Windows PowerShell) que permite copiar la entrada estándar de un comando a un archivo y así mismo seguir teniendo salida estándar por pantalla/terminal.
Copia la entrada estándar a cada ARCHIVO, y también a salida estándar.

Vamos a ver un ejemplo sencillo, ejecutamos el comando ps y a su vez volcamos su salida a un fichero:

$ ps | tee ps.txt
  PID TTY          TIME CMD
 2901 pts/6    00:00:00 bash
 3111 pts/6    00:00:00 ps
 3112 pts/6    00:00:00 tee
$ cat ps.txt
  PID TTY          TIME CMD
 2901 pts/6    00:00:00 bash
 3111 pts/6    00:00:00 ps
 3112 pts/6    00:00:00 tee

Hemos verificado que el contenido de la salida se ha almacenado en el fichero ps.txt y a su vez seguimos visualizandolo por pantalla, si no usaramos el comando tee y volcaramos la salida a un fichero no lo veríamos por pantalla (ver artículo redirigir stdin, stdout y stderr en Unix/Linux):

$ ps > ps.txt

El comando tee tiene muchas más posibilidades, recuerdo por ejemplo el artículo en el que explicabamos como guardar un fichero dentro de VIM cuando no tenemos permisos en vim:

:w !sudo tee %
[sudo] password for alex: