Cómo parecer un gurú de UNIX

Hola.

Os dejo una traducción / adaptación de un pequeño texto con algunas cosas que os pueden interesar a los nuevos sobre el uso de la consola y la línea de comandos. A ver si le vamos perdiendo el miedo.

(Original de Terence Parr, última actualización 30 de agosto de 2006)

UNIX se ha convertido en una plataforma extremadamente popular para el despliegue de software servidor, en parte debido a su seguridad y estabilidad, pero también porque tiene un rico juego de comandos de consola y herramientas de scripting. Los programadores usan esas herramientas para manipular el sistema de ficheros, procesar logs, y generalmente, automatizar tanto como sea posible.

Si estás interesado en ser un desarrollador de servidores serio, necesitas tener cierto dominio de una serie de herramientas UNIX, unas 15. Empezarás a ver similitudes entre ellas, particularmente las expresiones regulares, y pronto te encontrarás muy cómodo. Combinando comandos simples, puedes construir herramientas muy poderosas realmente rápido -mucho más que si quisieras crear la funcionalidad equivalente en C o Java, por ejemplo.

Esta lectura te llevará a través de los comandos básicos y te mostrará cómo combinarlos en patrones simples para proveer de sofisticadas funcionalidades como histografía. Este texto asume que sabes lo que es un shell y que tienes alguna familiaridad básica con UNIX.

(De paso, este texto ha obtenido bastante atención en la red y desafortunadamente, recibo correos de un montón de gente que tiene mejores soluciones o material que debería añadir. Yo sólo muestro qué he aprendido observando a gente buena en UNIX, así que no estoy diciendo que estas pistas sean las soluciones óptimas).

Todo es un flujo

Lo primero que necesitas saber, es que UNIX está basado en la idea de flujo de datos. Todo es un flujo, o aparenta serlo. Los dispositivos son flujos, los terminales son flujos, los procesos se comunican a través de flujos... etc. La entrada y salida de datos de un programa son flujos que puedes redirigir a un dispositivo, un fichero, o a otro programa.

Aquí hay un dispositivo de ejemplo, el dispositivo null, que elimina lo que se le envía. Por ejemplo, quieres ejecutar un programa, pero ignorar la salida.

$ ls > /dev/null # ignora la salida de ls

Donde "# ignora la salida de ls" es un comentario.

Muchos de los comandos que son cubiertos por este documento procesan stdin y envían el resultado a stdout. De esta forma, puedes ir procesando un flujo de datos de forma incremental conectando la salida de una herramienta a la entrada de otra mediante una tubería. Por ejemplo, la secuencia de tuberías siguiente muestra el número de ficheros del directorio actual modificados en Agosto:

$ ls -l | grep Ago | wc -l

Imagina el tiempo que te tomaría escribir su equivalente en C o Java. Puedes convertirte en un programador UNIX extremadamente productivo si aprendes a combinar las órdenes de consola simples.

Consiguiendo ayuda

Si necesitas conocer el funcionamiento de un comando, busca en su página de manual. Por ejemplo, para conocer a forndo el comando ls, teclea:

$ man ls

Y tendrás un resumen del funcionamiento dle programa y sus argumentos.

Si no puedes recordar el nombre de un comando, intenta usar apropos, el cual encuentra comandos y rutinas de librería relacionadas con la palabra dada. Por ejemplo para encontrar comandos para realizar sumas de control, teclea:

$ apropos checksum
cksum(1), sum(1)
md5(1)

Directorios y ficheros especiales

Un atajo a tu directorio personal, /home/usuario, es ~usuario. Por ejemplo, ~flynn es mi directorio personal, /home/flynn.

Cuando usas el shell, hay que tener presente siempre la noción de directorio acutal. El carácter punto "." es la representación del directorio actual y ".." es la representación del directorio superior. Así, para acceder al archivo test en el directorio actual, ./test es equivalente a test. Si test está en el directorio superior, usa ../test.

/ es el directorio raíz, del que cuelgan el resto de directorios; no hay especificación de unidades en UNIX (C:, D:, etc.)

El archivo .bash_profile es muy importante, ya que incluye los parámetros bajo los cuales se inician tus sesiones en el shell, incluyendo las siempre importantes variables de entorno CLASSPATH. Cada usuario tiene un fichero de inicialización de entorno en ~usuario/.bash_profile, y está conformado por código como:

PATH=$PATH:$HOME/bin

Lo normal es que lo edites para definir tus CLASSPATH y así te evitas definirlas a cada inicio de sesión.

export CLASSPAHT=".:/home/public/cs601/junit.jar"

El comando export implica que lo asignado a CLASSPATH sea visible a todos los procesos hijos (esto es, visible para todos los programas que inicies desde el shell)

Los básicos

cd

Para cambiar de directorio se usa cd (directorio) donde directorio puede ser "." o ".." para ir al directorio actual -no moverse- o ir al superior. También se puede especificar una ruta como cd /home/flynn/Descargas.

ls

Lista los ficheros en un directorio. El modificador -l se usa para mostrar los detalles de los mismos.

Si quieres ver los archivos ocultos (que empiezan por "."), usa el modificador -a.

Pueden combinarse distintos modificadores: ls -la, mostrará listará todos los ficheros de un directorio, incluyendo los ocultos, mostrando sus detalles.

Mostrar contenidos de ficheros

Aquí tienes cuatro útiles ejemplos sobre cómo mostrar los contenidos o porciones de un fichero. El primero es el muy comúnmente usado comando cat. Por ejemplo, para mostrar los contenidos de mi lista de ex-novias:

$ cat /home/flynn/cuidadito/zorrasimplacables.txt

Si un fichero es realmente grande (como mi lista de ex-novias), puedes usar more que trocea su salida en porciones pantalla-a-pantalla:

$ more /home/flynn/cuidadito/zorrasimplacables.txt

Si quieres ver las primeras o las úlitimas líneas de un fichero, usa head y tail, respectivamente.

$ head /home/flynn/cuidadito/zorrasimplacables.txt
$ tail /home/flynn/cuidadito/zorrasimplacables.txt

Puedes especificar cuántas líneas quieres mostrar añadiendo -número como argumento:

$ head -30 /home/flynn/cuidadito/zorrasimplacables.txt

Uno de los más útiles modificadores de tail muestra las últimas líneas de un fichero, y queda en espera, mostrando nuevas líneas conforme se van añadiendo. Ideal para monitorizar un fichero de log:

$ tail -f /var/log/mail.log

Si necesitas conocer cuántos caracteres, palabras o líneas hay en un fichero usa wc:

$ wc /home/flynn/cuidadito/zorrasimplacables.txt
     164      2916       37896  /home/flynn/cuidadito/zorrasimplacables.txt

Donde los números son, por orden (e inventados), líneas, palabras, caracteres. Para mayor claridad, puedes usar wc -l para mostrar únicamente el número de líneas.

pushd, popd

En lugar de cd puedes usar pushd para guardar el directorio actual e ir (cd) al directorio especificado. Por ejemplo,

$ pwd
/home/flynn
$ pushd /tmp
/tmp ~
$ pwd
/tmp
$ popd
~
$ pwd
/home/flynn

top

Para observar una representación dinámica de los procesos de tu máquina, usa top.

ps

Para mostrar (muy detalladamente) todos los procesos de una máquina, usa ps auxwww.

chmod

Para cambiar los permisos de un fichero o directorio, usa chmod. Los permisos son palabras octales de 3 dígitos con 3 bits por dígito: rwxrwxrwx. Los tres primeros dígitos son los permisos del propietario del fichero, los segundos son para su grupo y los restantes para el resto. 644 es el valor común para los ficheros, que serían 110100100 o rw-r--r--. Si haces un ls -l puedes ver los permisos de cada fichero del directorio. 755 es el valor común para los directorios: rwxr-xr-x. Los directorios necesitan ser ejecutables (x) para habilitar su entrada con cd. 755 es una abreviatura para u=rwx,go=rx. Donde "u" es usuario, "g" es grupo y "o" es otros.

Usa el modificador "-R" para cambiar recursivamente los permisos de ficheros y directorios a partir del directorio actual.

Buscando en los flujos

Bajo éste escatológico subtítulo, vamos a conocer una de las más útiles herramientas disponibles en UNIX y una de las que más vas a emplear: grep. Esta herramienta busca coincidencias con expresiones regulares (que incluyen palabras simples) y muestra las líneas con coincidencias en stdout.

La implementación más simple busca una secuencia de caracteres particular en un juego de ficheros. Aquí hay un ejemplo que busca cualquier referencia a "p0rn" en el directorio actual:

$ grep p0rn *

Encontrarás la expresión regular punto "." útil. Representa cualquier caracter y se combina normalmente con el asterisco, que simboliza "cero o más del ítem al que precede". Recuerda que encerrar la expresión entre comillas simples no modifica el argumento. El siguiente ejemplo busca referencias a todas las páginas que comiencen por "forum" en el access.log de un servidor lighttpd:

$grep '/forum/.*' /var/log/lighttpd/access.log

O, de forma equivalente:

$cat /var/log/lighttpd/access.log | grep '/forum/.*'

El segundo método es útil cuando quieres procesar una colección de ficheros en un único flujo como:

$ cat /var/log/lighttpd/access*.log | grep '/forum/.*'

Si necesitas buscar una cadena al principio de una línea, usa el modificador '^':

$ grep '^192.77.105.200' /var/log/lighttpd/access*log

Éste comando mostrará todas las líneas en todos los archivos access*.log que comiencen por la IP 195.77.105.200.

Si quisieras invertir el patrón de búsqueda de forma que se mostrasen las líneas que no incluyan dicho patrón, usa el modificador -v. Aquí hay un ejemplo que busca referencias a líneas que no contengan referencias a "/images":

$ cat /var/log/lighttpd/access.log | grep -v '/images'

Ahora imagina que tienes un archivo log de accesos http y quieres filtrar peticiones de página hechas por "spiders" de buscadores. Si tienes un fichero con las IP's de dichos spiders lamado spider.IPs, puedes encontrar todas las vistas de página no solicitadas por spiders, así:

$ cat /var/log/lighttpd/access.log | grep -v -f /tmp/spider.IPs

Finalmente, para ignorar entre mayusculas y minúsculas, usa -i.

Traduciendo Flujos

Transformar un flujo de texto es una operación fundamental en UNIX. PERL es una buena herramienta para ello, pero como no me gusta PERL (N.del T: allá el), uso tres herramientas: tr, sed y awk. Tanto PERL como estas tres herramientas son utilidades línea-a-línea en las que se desenvuelven bien sólo en patrones totalmente incluídos en una única línea. Si necesitas procesar cosas más complicadas como XML o necesitas parsear a un lenguaje de programación, usa una herramienta gramática independiente del contexto como ANTLR.

tr

Para el manipulado de espacios en blanco, encontrarás mucha utilidad en tr.

Si tienes columnas de datos separadas por espacios y quieres colapsarlas en una única columna de datos, pídele a tr que reemplace al espacio en blanco por el retorno de carro:

$ tr ' ' '\n'

Consideremos el archivo de datos de entrada /home/flynn/gente:

jaimito pepito miguelito
guillermito ramoncito antoñito

Para tener todos esos nombres en una columna, usa:

$ cat /home/flynn/gente | tr ' ' '\n'

Si quieres colapsar todas las secuencias de espacios en blanco en un único espacio usa:

$ tr -s ' '

Para realizar la conversión de un fichero win a UNIX, debes deshacerte del caracter '\r'. Usa ésto:

$ tr -d '\r'

sed

Si eliminar o convertir caracteres únicos no basta, puedes usar sed (stream editor, editor de flujos) para reemplazar o borrar fracciones de texto que coincidan con una expresión regular. Por ejemplo, para borrar a jaimito del archivo de antes:

$ cat /home/flynn/gente | sed 's/jaimito//'

Lo cual sustituye a jaimito por nada. Si hay múltiples coincidencias en una línea, usa el sufijo "g" para indicar "global" en esa línea, de otro modo sólo la primera coincidencia será eliminada:

$ ... | sed 's/jaimito//g'

Si quieres reemplazar vista.jpg por mandriva.jpg, usa:

$ ... | sed 's/vista.jpg/mandriva.jpg/'

Si pretendes renombrar archivos de forma masiva, debes encontrar equivalencias en el nombre de archivo con una expresión regular y hacer referencia a ella con \1:

$... | sed 's/\(.*\).asp/\1.jsp/'

Donde lo que se incluye entre \(...)\) agrupa el texto al que puedes referirte con \1.

Para eliminar todo lo que se encuentre detrás del carácter ',' hasta el final de cada línea, se usa el marcador de fin de línea $:

$...| sed 's/,.*$//' # Elimina contenido desde el carácter coma hasta el fin de línea

awk

Cuando necesites trabajar con columnas de datos, o ejecutar pequeñas porciones de código para cada línea de un archivo que coincida con un patrón, usa awk. Los guiones de awk se componen de pares patrón-acción. Aunque puedes programar acciones lo bastante complejas para necesitar un fichero por separado para contenerlas, puedes realizar cosas sorprendentes usando únicamente un argumento en la línea de comandos.

awk asume que las líneas que va leyendo están separadas en campos (p.e., columnas) separados por espacios en blanco. Los campos se referencian en una acción a través de $1, $2,... y $0 hace referencia a la línea completa.

El esquema del par patrón-acción es el siguiente:

patrón {acción}

Si omites el patrón, la acción se ejecuta para cada línea. Omitir la acción implica la impresión de la línea. Puedes separar varios pares por medio de retornos de carro o semicolon.

Consideremos este fichero de entrada, situado en /var/mail/users.txt:

flynn Flynn, Kevin
allan1 Bradley, Allan
edillinger Dillinger, Edward

Si quieres obtener una lista de nombres de usuario, dile a awk que imprima la primera columna:

$ cat /var/mail/users.txt | awk '{print $1;}'

Si lo que quieres es convertir los nombres de usuario en cuentas de correo, usa la función printf, similar a la homónima en C:

$ cat /var/mail/users.txt | awk '{printf("%s@emcom.net,",$1);}'

Sí, falta el \n en la cadena de printf, pero así tenemos la salida de awk en una sóla línea separada por comas, lista para pegar en el campo destino de un programa de correo...

flynn@emcom.net, allan1@emcom.net, edillinger@emcom.net

Hasta puedes reordenar las columnas en la salida. Por ejemplo, vamos a imprimir nombres y apellidos:

$ cat /var/mail/users.txt | awk '{printf("%s %s\n", $3, $2);}'

Fíjate que la coma del apellido todavía aparece como parte de su columna:

Kevin Flynn,
Allan Bradley,
Edward Dillinger,

Pues usamos una tubería hacia tr (o sed) para eliminarla:

$ cat /var/mail/users.txt | \
  awk '{printf(%s %s\n", $3, $2;}' | \
  tr -d ','

Y lo que obtenemos es:

Kevin Flynn
Allan Bradley
Edward Dillinger

También puede usarse awk para examinar los valores de un contenido. Para sumar la primera columna del siguiente archivo (en home/flynn/estado.txt)

150 paranoides_espaciales
340 los_invasores
75 ataque_a_los_marcianos

Simplemente hay que usar el siguiente comando:

$ awk '{n+=$1; END {print n;}' < /home/flynn/estado.txt

La partícula END es un patrón especial que significa "después de procesar el flujo".

Si lo que pretendemos es sumar los valores menores o iguales a, por decir algo 200, pueden usarse sentencias if:

$ awk '{if ($1<=200) n+=$1;} END {print n;}' < /home/flynn/estado.txt

En este caso, veremos la salida 225 (150 de paranoides + 75 de ataque_a_los_marcianos).

Utilizar awk para seleccionar una columna particular es muy común cuando procesamos archivos de log. Consideremos un archivo de log de accesos a una web (/var/log/lighttpd/mainman/access.log)
Esto es un extracto trampeado de mi propio access.log, con los primeros accesos al blog desde la migración) que tiene el siguiente esquema:
IP DOMINIO FECHA SOLICITUD RUTA DATOS_VISITANTE

127.0.0.1 themainman.kicks-ass.net [02/Nov/2008:02:50:59] GET 
/wp-content/themes/K2%20v096/style.css Mozilla/5.0 (X11  U  Linux i686  es-ES  rv:1.9.0.3)
Gecko/2008092903 Mandriva/1.9.0.3-1mdv2009.0 (2009.0) Firefox/3.0.3

Vamos a ver qué peticiones se le hicieron al servidor:

 
$ awk '{print $5;}' < /var/log/lighttpd/mainman/access.log
(parrafada monumental)

Bueno, vamos a buscar las conexiones hechas desde mi PocketPC HTC, y además vamos a mostrar la IP de la conexión y la fecha:

$ grep 'HTC' < /var/log/lighttpd/mainman/acces.log | awk '{print $1,$2,$5;}'
(parrafada más razonable)

Si queremos tener una lista de ip's únicas, podemos ordenar la salida y luego usar uniq:

$ awk '{print $1;}' < /var/log/lighttpd/mainman/access.log | sort | uniq

El comando uniq colapsa todas las líneas repetidas en una única línea. Cuidadín, líneas iguales.

Tarballs

Nota: El nombre viene de una palabra similar, hairball (bolas de pelo que vomitan los gatos), Estoy bastante seguro. (N. del adap: Casi me caigo de la silla de la risa </ironic>)

Para recopilar un conjunto de archivos y directorios en un único archivo, se usa tar. Por ejemplo, para empaquetar todo tu /home y poner el tarball en /tmp:

$ cd ~flynn
$ cd .. # Subir al directorio superior al que se quiere empaquetar
$ tar cvf /tmp/flynn.backup.tar ./flynn

Por convención se usa .tar como extensión. Para desempaquetar el archivo:

$ cd /tmp
$ tar xvf flynn.backup.tar

Tar desempaqueta cosas en el directorio actual.

Después de ejecutar el desempaquetado, encontrarás un nuevo directorio, /tmp/flynn, el cual es una copia de tu home. Fíjate cómo tu tarball indica la estructura de directorios cuando se desempaqueta. El hecho de incluir flynn durante la creación del tar significa que se creará ese directorio cuando se desempaquete. Por contra, lo siguiente también crearía una copia de /home/flynn, pero sin un directorio raíz flynn:

$ cd ~flynn
$ tar cvf /tmp/flynn.backup.tar *

Muchas veces podrás ahorrar espacio usando el argumento z. El tarball será comprimido con gzip y deberías usar la extensión .tar.gz:

$ cd ~flynn
$ cd .. # volvemos a ir al directorio superior al que queremos comprimir
$ tar cvfz /tmp/flynn.backup.tar.gz flynn

Para descomprimir, necesitaremos incluír el argumento z igualmente:

$ cd /tmp
$ tar xvfz flynn.backup.tar.gz

Si tienes un archivo grande a comprimir, usa gzip:

$ gzip -d p0rn.gz

Para mostrar texto de un fichero que está actualmente comprimido, usa zcat:

$ zcat labibliaenverso.gz

Moviendo archivos entre máquinas

rsync

Cuando necesitas un mirror de un directorio de una máquina en otra máquina, usa rsync. Este comando compara todos los archivos en un árbol de directorios dado y copia todo aquello que haya cambiado en el directorio mirror que hayamos definido en otra máquina. Por ejemplo, aquí vemos cómo "sincronizar" todos los archivos de log del servidor webserver.themainman.kicks-ass.net hasta bestiaparda.themainman.kicks-ass.net, que es la máquina desde la que ejecutamos rsync:

$ hostname
bestiaparda.themainman.kicks-ass.net
$ rsync -rabz -e ssh -v 'flynn@webserver.themainman.kicks-ass.net:/var/log/lighttpd/*' 
/backup/web/logs

rsync borrará o modificará archivos para asegurarse de que permanezcan idénticos. Esto es peligroso si borras un archivo por error en el server -también desaparecerá de la copia-. Añadiendo el argumento --suffix indicamos a rsync que haga una copia de cada archivo existente antes de sobreescribirlo:

$ hostname
bestiaparda.themainman.kicks-ass.net
$ rsync -rabz -e ssh -v --suffix .rsync_`date '+%d%m%Y'` 'flynn@webserver.themainman.kicks-ass.net
:/var/log/lighttpd*' /backup/web/logs

Donde `date '+%d%m%Y'` significa "ejecuta éste comando date".

Para excluír ciertos patrones de la sincronicación se usa el modificador --exclude:

$ rsync -rabz --exclude=entyitymanager/ (blablabla) /backup/web/logs

scp

Para copiar archivos o directorios manualmente, usa scp:

$ scp lecturasejemplares.html flynn@webserver.themainman.kicks-ass.net~flynn/lecturas

Análogamente al comando cp, puede usarse el modificador -r para copiar directorios recursivamente.

Miscelánea

find

Muchos GUI para Linux tienen una herramienta de búsqueda, pero desde la línea de comandos, puedes usar find. Para encontrar todos los ficheros llamados .guarr empezando por el directorio ~flynn/guarreridas/p0rn, por ejemplo:

$ find ~flynn/guarreridas/p0rn -name '.guarr'

La acción por defecto es mostrar los archivos.

Puedes especificar una expresión regular para buscar coincidencias. Por ejemplo, para buscar archivos xml por todo tu home:

$ find ~ -name '*.xml' -print

Atentos al uso de las comillas simples para prevenir la expansión de la línea de comando: quieres que '*' sea pasado al comando find.

Puedes ejecutar un comando por cada fichero o directorio encontrado que coincida con el patrón. Por ejemplo para borrar los resultados de la búsqueda anterior:

$ find ~ -name '*.xml' -exec rm {} \;

Donde {} implica "archivo coincidente actual". El final del comando debe terminar por ";" y para que el sistema no se haga un lío con la expansión de la línea de comando, debes introducirlo como carácter escapado.

También se puede especificar información sobre fechas y horas en la búsqueda. Aquí hay un script sencillo que busca y elimina ficheros de más de 14 días:

#!/bin/sh

BACKUP_DIR=/var/backup
# número de días a conservar los backups
MAXIMO=14 # en días
MAXIMO_MINUTOS=$[ $MAXIMO * 60 * 24 ]
# Cizallando
find $BACKUP_DIR/* -cmin +$MAXIMO_MINUTOS -type d -exec rm -rf {} \;
echo "MWAHAHAHAHAH!"

fuser

Vamos a fisgonear un poco. Con fuser podemos conocer quién está usando un puerto determinado, como el HTTP (80). Aunque hay que ser root para usarlo:

$ su -
Contraseña:
# fuser -n tcp 80
80/tcp:              13476 13477 13478 13479 13480
13481 13482 13483 13484 13486 13487 13489 13490 13491
13492 13493 13495 13496 13497 13498 13499 13500 13501 13608

La salida del programa indica la lista de procesos asociados al puerto dado. Luego es trivial ver qué usuario ha lanzado cada proceso.

whereis

En ocasiones, quieres usar un comando, pero no está en tu PATH y no sabes / puedes recordar dónde está. Con whereis puedes mirar en las localizaciones standard de unix para el comando.

$ whereis fuser
fuser: /sbin/fuser
$ whereis ls
ls: /bin/ls

En función del UNIX que usemos, también muestra las páginas de man

which

A veces, podemos ejecutar la versión equivocada de un comando y necesitamos saber qué versión del mismo indica nuestro PATH que debería usarse. Usando which lo sabremos:

$ which java
/usr/bin/java

Si no se encuentra en nuestro path podremos ver algo como:

$ which java
/usr/bin/which: no java in (/usr/local/bin:/usr/local/bin:/bin:/usr/bin:/usr/
X11R6/bin:/usr/X11R6/bin:/home/flynn/bin)

kill

Para enviar señales a los procesos, se usa kill. Normalmente se usa kill (pid). El pid puede localizarse con ps o top.

Usa kill -9 (pid) para matar un proceso que se niega a ello; este sistema lo mata bien muerto.

traceroute

Si tienes problemas para acceder a un site, puedes usar traceroute para comprobar la secuencia de saltos (hops) que requiere alcanzarlo:

# traceroute blogdrake.net
traceroute to blogdrake.net (91.121.174.173), 30 hops max, 40 byte packets
 1  * * *
 2  * * *
 3  * * *
 4  * * *
 5  * So4-1-0-0-grtmadde1.red.telefonica-wholesale.net (84.16.12.54)  42.258 ms  52.211 ms
 6  GE2-3-0-0-grtmadde2.red.telefonica-wholesale.net (213.140.38.46)  80.626 ms  48.267 ms  48.243 ms
 7  * * *
 8  ae-11-11.car1.Madrid1.Level3.net (4.69.135.173)  114.265 ms  114.455 ms  114.605 ms
 9  30g.level3.mad-1-6k.routers.ovh.net (213.251.130.73)  115.079 ms * *
10  20g.gsw-1-6k.routers.ovh.net (213.251.128.41)  125.013 ms * *
11  160g.rbx-1-6k.routers.ovh.net (213.186.32.226)  160.498 ms * *
12  masai.masqueredes.com (91.121.174.173)  73.634 ms  73.698 ms  83.029 ms

(nota: los saltos en blanco que se ven son los del proxy, el servidor de dominio Windorls y el firewall guarro que hay en la red desde la que estoy conectado en este momento. El salto 7 diría que es el del proxy transparente de la Timo).

¿Cuál es mi IP?

# ifconfig

Bajo el interfaz en uso (en este caso eth0) podemos ver nuestra direción:

eth0      Link encap:Ethernet  HWaddr 00:1D:72:0F:98:09
          inet addr:192.168.0.56  Bcast:192.168.0.255  Mask:255.255.255.0
          inet6 addr: fe80::21d:72ff:fe0f:9809/64 Scope:Link

Combinaciones útiles

Cómo matar un conjunto de procesos

Si necesitamos matar todos los procesos java ejecutados por flynn puedes ejecutar killall java si eres flynn y usas linux, o generar un "script kill" tal que así:

$ ps auxwww|grep java|grep flynn|awk '{print "kill -9 ",$2;}' > /tmp/killflynn
$ bash /tmp/killflynn # ejecuta el script resultante

El script resultante en /tmp/killflynn sería algo así:

kill -9 1021
kill -9 1023
kill -9 1024

Nota: killall es específico de Linux. En otros UNIX, como Solaris usando killall puedes cargarte todos los procesos java en ejecución sin importar el usuario.

Cómo hacer un histograma

Un histograma es un juego de resultados, pares de valores que indican cuantas veces ocurre el valor. La operación básica es ordenar, luego contar cuántos valores aparecen en una fila y después ordenar de forma inversa para que
el valor más alto aparezca al principio del informe.

$ ... | sort | uniq -c | sort -r -n

Fijaos que sort ordena toda la línea, pero la primera columna es significativa del mismo modo que la primera letra del apellido lo es para establecer un orden alfabético.

uniq -c colapsa todas las secuencias repetidas de valores, pero muestra el número de apariciones antes del valor. Vamos a ver un ejemplo completo:

$ awk '{print $1;}' < /var/log/lighttpd/mainman/access.log | sort | uniq
127.0.0.1
77.210.32.61
77.210.62.30
83.54.69.231

Si ahora añadimos -c a uniq:

$ awk '{print $1;}' < /var/log/lighttpd/mainman/access.log | sort | uniq -c
188 127.0.0.1
17 77.210.32.61
11 77.210.62.30
24 83.54.69.231

Y ahora sólo falta hacer la ordenación inversa de las líneas en función de la primera columna:

$ awk '{print $1;}' < /var/log/lighttpd/mainman/access.log | sort | uniq -c |sort -r -n
188 127.0.0.1
24 83.54.69.231
17 77.210.32.61
11 77.210.62.30

Tal vez quieras hacer un histograma de accesos a un directorio concreto. Puedes filtrar los resultados antes de que awk envíe su flujo de salida a sort:

$ grep wp-admin /var/log/lighttpd/mainman/access.log | awk '{print $1;}' | sort | uniq -c |sort -r -n
43 127.0.0.1

43 accesos desde el propio servidor, como debe ser ;-)

Generando scripts y programas

Me gusta automatizar tanto como sea posible. A veces ello implica escribir un programa que genera otro programa o script.

Procesando archivos de correo

Quería una secuencia de comandos SQL que actualizara la base de datos cada vez que un correo viniese rebotoado.

Procesar el archivo mail es bastante fácil cuando te das cuenta que puedes encontrar el código de error seguido de la dirección de correo. Un correo rebotado tiene ésta pinta:

From MAILER-DAEMON@localhost.localdomain Wed Nov 5 17:32:33 2008
Return-Path: <>
Received: from mail.themainman.kicks-ass.net (mail.themainman.kicks-ass.net [XXX.XXX.XXX.XXX])
by localhost.localdomain (8.9.3/8.9.3) with ESMTP id XXXXXXXX
for <notifications@themainman.kicks-ass.net>; Wed, 5 Nov 2008 17:32:32 -0800
Received: from localhost (localhost)
by mail.themainman.kicks-ass.net (8.11.6/8.11.6) id XXXXXXXXXX;
Wed, 5 Nov 2008 17:32:02 -0800
Date: Wed, 5 Nov 2008 17:32:02 -0800
From: Mail Delivery Subsystem <MAILER-DAEMON@mail.themainman.kicks-ass.net>
Message-Id: <200201100132.g0A1W2o02285@mail.themainman.kicks-ass.net>
To: <notifications@themainman.kicks-ass.net>
MIME-Version: 1.0
Content-Type: multipart/report; report-type=delivery-status;
boundary="g0A1W2o02285.1010626322/mail.themainman.kicks-ass.net"
Subject: Returned mail: see transcript for details
Auto-Submitted: auto-generated (failure)
This is a MIME-encapsulated message
--g0A1W2o02285.1010626322/mail.themainman.kicks-ass.net
The original message was received at Wed, 5 Nov 2008 17:32:02 -0800
from localhost [127.0.0.1]
----- The following addresses had permanent fatal errors -----
<estonova@quetevayandando.com>
(reason: 550 Host unknown)
----- Transcript of session follows -----
550 5.1.2 <estonova@quetevayandando.com>... Host unknown 
(Name server: quetevayandando.com: host not found)
...

Miremos la última línea, que contiene el error 550 SMTP. El código de error está al principio de la línea, hay que eliminar a los símbolos <>, quitar el "..." y usar awk para generar el SQL

Algo así:

# Este script funciona en maildir y mailboxes
# Busca errores 550 o 554 SMTP y los convierte en comandos SQL
grep -E '^(550|554)' | \
sed 's/[<>]//g' | \
sed 's/\.\.\.//' | \
awk "{printf(\"UPDATE PERSON SET rebotado=1 WHERE email='%s';\n\",\$3);}" >> rebotados.sql

Hay que representar $3 como secuencia de escape porque tiene significancia para bash y quiero que awk vea el signo dolar.

¿Me están juankeando?

Para controlar los intentos de login fallidos: /var/log/messages

Para controlar los últimos logueos: last

Para ver quién tiene sesión iniciada y qué hace: w

Controla si hay cambios en /etc/passwd

Usa fuser para tener los puertos supervisados

Controla si la CPU está saturada por procesos raros / desconocidos.

Apostilla mía: Contrólalo TODO, contrólalo SIEMPRE.