Comando tail de Linux

El comando tail de Linux es una de las he­rra­mie­n­tas fu­n­da­me­n­ta­les de la línea de comandos. Pri­n­ci­pa­l­me­n­te, el comando se utiliza para mostrar las últimas líneas de un archivo (de texto) o para re­s­tri­n­gir la salida de un comando de Linux a un ámbito concreto. De esta manera, el comando tail de Linux pertenece a un conjunto de comandos al que también pertenece el comando head de Linux y los comandos ‘cat’ y ‘less’. Este conjunto de comandos de Linux se utiliza para mostrar el contenido de archivos de texto.

El comando tail de Linux forma parte de las GNU Core Utilities (Coreutils). Se trata de una colección de comandos co­n­te­ni­dos en el sistema operativo de código abierto Linux fu­n­da­me­n­ta­les para su línea de comandos. Las Coreutils se publican bajo una licencia de código abierto y su descarga está di­s­po­ni­ble para una variedad de sistemas ope­ra­ti­vos di­fe­re­n­tes.

La fu­n­cio­na­li­dad básica del comando tail de Linux es mostrar las últimas líneas de un archivo. Para ello, debes saber que los datos que se escriben en un archivo se van añadiendo al final, dejando, de esta manera, los más recientes al final. Es por esta razón que tail de Linux nos permite comprobar si se han añadido nuevos datos a un archivo. Por lo tanto, el comando tail de Linux suele usarse para analizar los archivos de registro y mo­ni­to­ri­zar­los.

Muchos programas, es­pe­cia­l­me­n­te los se­r­vi­do­res web como Apache o nginx escriben in­fo­r­ma­ción sobre estados en los llamados archivos de registro. En el caso de los registros del servidor, los archivos contienen en cada línea una marca de tiempo, la URL del recurso so­li­ci­ta­do y la dirección IP del so­li­ci­ta­n­te entre otros.

Los archivos de registro crecen con cada petición de recurso al sistema. Para limitar el tamaño pasado un cierto punto, los archivos de registro suelen ser “rotados”. El archivo de registro se comprime y se archiva con un nuevo nombre. A co­n­ti­nua­ción, se crea un nuevo archivo de registro vacío con el nombre original. Aquí tienes un resumen de los archivos de registro más usados en Ubuntu Linux:

El comando tail de Linux se introduce en la línea de comandos. Como es habitual, se introduce el nombre del comando seguido de pa­rá­me­tros op­cio­na­les. El comando concluye con el nombre o la ruta de uno o varios archivos. Veamos primero la notación genérica:

Sin pa­rá­me­tros, la notación del comando tail de Linux es más simple y queda de la siguiente manera:

Escrito de esta manera, el comando tail de Linux muestra las últimas diez líneas del archivo es­pe­ci­fi­ca­do. Esto es útil para ver los datos más recientes escritos en el archivo.

El comando tail de Linux puede ser mo­di­fi­ca­do por medio de pa­rá­me­tros. Como parte de los coreutils de GNU, hay un formato largo para cada parámetro. Los pa­rá­me­tros más uti­li­za­dos tienen también un formato abreviado, que se lleva usando desde siempre. Aquí tienes un resumen de los pa­rá­me­tros más usados:

Los pa­rá­me­tros básicos del comando tail de Linux, mostrados an­te­rio­r­me­n­te, son análogos en su fu­n­cio­na­mie­n­to a los del comando head. Sin embargo, mientras que el comando head muestra el principio de un archivo, el comando tail de Linux muestra su final. Ahora bien, el comando puede hacer mucho más.

En pa­r­ti­cu­lar, el comando tail de Linux pro­po­r­cio­na una variedad de opciones para el se­gui­mie­n­to de los archivos en busca de cambios. El comando tail de Linux permite mostrar co­n­ti­nua­me­n­te datos añadidos al final de un archivo. Por co­n­si­guie­n­te, el comando es es­pe­cia­l­me­n­te útil para el se­gui­mie­n­to de los archivos de registro. Este proceso también se conoce como “live tail”. Aquí tienes un resumen de los pa­rá­me­tros más usados:

En la do­cu­me­n­ta­ción de coreutils, el comando tail de Linux aparece en la sección “Output of parts of files” (Salida de parte de archivos). Piensa que en este caso “archivos” es un término muy amplio. El término “flujos de texto” es más preciso.

Siguiendo la filosofía de Unix, los comandos de la línea de comandos utilizan flujos de texto como formato universal de entrada y salida. El término “flujos de texto” hace re­fe­re­n­cia, sobre todo, a archivos, pero también la típica entrada y salida de la línea de comandos. Además, las “pipes”, llamadas “tuberías” en español, son de gran im­po­r­ta­n­cia. Permiten encadenar varios comandos. Para ello, la salida de un comando se transmite como entrada al siguiente comando.

La idea detrás de encadenar varios comandos se remonta, de nuevo, a la filosofía de Unix. En lugar de de­sa­rro­llar comandos complejos para tareas co­m­ple­ta­me­n­te di­fe­re­n­tes, existe un conjunto re­la­ti­va­me­n­te asequible de comandos generales. Siguiendo la máxima “do one thing, and do it well” (en español “haz una cosa, y hazla bien”), cada comando tiene una fu­n­cio­na­li­dad cla­ra­me­n­te definida. Los comandos utilizan flujos de texto como interfaz universal y pueden co­m­bi­nar­se para crear so­lu­cio­nes nuevas.

Los si­guie­n­tes ejemplos genéricos se basan en los pa­rá­me­tros básicos del comando tail de Linux pre­se­n­ta­dos al principio. Para ver ejemplos que utilicen los pa­rá­me­tros más avanzados, consulta la sección sobre la mo­ni­to­ri­za­ción de los archivos de registro que se encuentra más abajo.

La mayoría de los ejemplos mostrados en esa sección combinan el comando tail de Linux con uno o más comandos de Linux. Es aquí cuando son útiles las pipes me­n­cio­na­das an­te­rio­r­me­n­te, que permiten tra­n­s­mi­tir la salida de un comando a la entrada del siguiente en la cadena.

En el caso más sencillo, uti­li­za­mos el comando tail de Linux para mostrar las últimas líneas de un archivo. Para probar esto, sustituye el marcador de posición ‘<archivo>‘ por el nombre o la ruta de un archivo de texto que exista en tu sistema. En este ejemplo uti­li­za­mos el parámetro -n y sacamos las tres últimas líneas de un archivo:

A menudo es útil mantener un ojo en el contexto del archivo procesado con el comando tail de Linux. Para mostrar las líneas numeradas, primero pro­ce­sa­mos el archivo con el comando nl (el nombre viene de “line numbering”— “nu­me­ra­ción de líneas”) y ca­na­li­za­mos la salida de la pipe de nuevo al comando tail de Linux:

El comando history muestra los comandos in­tro­du­ci­dos an­te­rio­r­me­n­te en la línea de comandos. No­r­ma­l­me­n­te, uno solo se interesa por los últimos comandos eje­cu­ta­dos. Además, mostrar el historial de comandos al completo puede revelar datos sensibles. Aquí tra­n­s­mi­ti­mos la salida del comando history al comando tail de Linux y mostramos las últimas cinco líneas:

Veamos un ejemplo más complejo. Vamos a eliminar los diez archivos más antiguos de un di­re­c­to­rio que contiene archivos de copia de seguridad. Para ello, uti­li­za­re­mos cuatro comandos de Linux, que son ‘ls’, ‘tail’, ‘xargs’ y ‘rm’:

¿Qué ocurre exac­ta­me­n­te aquí?

1. El comando ‘ls’ muestra una lista de los archivos de un di­re­c­to­rio

Con el parámetro ‘-t’, los archivos se ordenan por fecha de mo­di­fi­ca­ción. Los archivos más antiguos quedan al final de la lista.

Uti­li­za­mos el patrón de búsqueda ‘*.bak’ para la fuente de datos. Este es una extensión de archivo común para los archivos de copia de seguridad. También actúa como pro­te­c­ción adicional, para que, al eje­cu­tar­lo, no borremos archivos im­po­r­ta­n­tes ac­ci­de­n­ta­l­me­n­te.

A través de la pipe tra­n­s­mi­ti­mos la lista de archivos al comando tail de Linux.

1. Usando el comando tail de Linux sin es­pe­ci­fi­car ningún parámetro mostramos los últimos diez archivos de la lista. Los nombres de los archivos que se muestran en pantalla son los más antiguos del di­re­c­to­rio.
2. El comando xargs precisa la entrega de una lista de archivos y el nombre de un comando. Xargs ejecutará el comando que se le indique y le ali­me­n­ta­rá la lista de archivos como ar­gu­me­n­tos.

En nuestro ejemplo, el comando tail de Linux nos devuelve un texto con varias líneas. Cada línea contiene el nombre de un archivo que se va a eliminar. A través de ‘xargs’, los nombres de los archivos se separan de sus líneas re­s­pe­c­ti­vas y se pasan como ar­gu­me­n­tos al comando rm.

1. Uti­li­za­mos el comando rm para eliminar archivos en Linux. El comando rm borra los archivos que ha recibido en forma de ar­gu­me­n­tos.

Ten en cuenta, que los archivos borrados no se envían a la papelera, sino que se eliminan al instante.

Hay que tener cuidado al borrar archivos desde la línea de comandos de Linux. Para que puedas probar a usar los comandos de nuestro ejemplo sin preo­cu­pa­cio­nes, primero deberías crear un di­re­c­to­rio con archivos de prueba. Esto lo puedes hacer eje­cu­ta­n­do el siguiente código en la línea de comandos:

A co­n­ti­nua­ción, creamos un di­re­c­to­rio de prueba ‘tail-test/’ en el es­cri­to­rio y cambiamos al di­re­c­to­rio. Después, creamos 100 archivos de prueba vacíos que van del ‘test-1.bak’ al ‘test-100.bak’. Fi­na­l­me­n­te, eje­cu­ta­mos el código para eliminar los diez archivos más antiguos:

Hasta ahora, hemos visto el fu­n­cio­na­mie­n­to general del comando tail de Linux. En los si­guie­n­tes ejemplos, nos centramos en la mo­ni­to­ri­za­ción en directo de los archivos de registro del servidor (“live tail”).

En estos ejemplos partimos del servidor web Apache2 con Ubuntu Linux. Allí, los archivos de registro se en­cue­n­tran en el di­re­c­to­rio ‘/var/log/apache2/’. En otras di­s­tri­bu­cio­nes de Linux, la ubicación puede ser otra. Lo mismo ocurre con otros se­r­vi­do­res web, como el servidor web nginx.

Una ejecución normal del comando tail de Linux muestra el número de líneas es­pe­ci­fi­ca­do una única vez. Si, a co­n­ti­nua­ción, se añaden nuevos datos al final del archivo, el comando debe eje­cu­tar­se de nuevo. Para estos casos en concreto existen algunos pa­rá­me­tros avanzados que indican al comando que mo­ni­to­ri­ce un archivo en busca de cambios y que muestre esos cambios co­n­ti­nua­me­n­te.

Veamos cómo funciona uti­li­za­n­do como ejemplo el registro de acceso del servidor web Apache2. Eje­cu­ta­mos el comando tail de Linux con el parámetro -f e in­tro­du­ci­mos la ruta y nombre del archivo de registro:

Cuando se ejecuta de esta manera, los cambios en el registro de acceso se emiten co­n­ti­nua­me­n­te. Si hay muchos accesos por unidad de tiempo, el método deja de ser práctico. El registro tendría cambios tan fre­cue­n­te­me­n­te que el terminal se inundaría de datos. Si ocurre esto, pulsa la co­m­bi­na­ción de teclas “Ctrl+C” para cancelar la ejecución actual de la live tail.

Si eje­cu­ta­mos el comando tail de Linux con el parámetro -f, se mo­ni­to­ri­za el archivo es­pe­ci­fi­ca­do. Pero, si el archivo se elimina, el comando deja de mostrar los cambios. Como hemos explicado al principio, los archivos de registro se rotan pe­rió­di­ca­me­n­te. Por lo tanto, se crea un nuevo archivo con el nombre antiguo. Para seguir mo­ni­to­ri­za­n­do un archivo de registro a pesar de la rotación, uti­li­za­mos el parámetro -F:

Hasta ahora, solo hemos utilizado el comando tail de Linux para procesar un archivo. Sin embargo, el comando también permite mo­ni­to­ri­zar varios archivos a la vez. Aquí uti­li­za­mos el patrón de búsqueda ‘*.log’ para mo­ni­to­ri­zar co­n­ti­nua­me­n­te todos los archivos con la extensión ‘.log’:

Cuando pro­ce­sa­mos varios archivos podemos ayudarnos de dos pa­rá­me­tros usados ha­bi­tua­l­me­n­te. En primer lugar, podemos omitir la salida de los nombres de los archivos con el parámetro ‘-q’:

Del mismo modo, podemos usar el parámetro ‘-v’ para forzar la salida de los nombres de los archivos. Se suele usar cuando el patrón de búsqueda devuelve un solo archivo:

Hasta ahora hemos mo­ni­to­ri­za­do un archivo de registro para detectar cualquier tipo de cambio. Sin embargo, es más común delimitar la salida a cambios es­pe­cí­fi­cos. Podemos usar el comando grep para limitar la salida de cambios del archivo de registro a un patrón de búsqueda. Aquí tienes un ejemplo genérico de su uso:

Es muy común mo­ni­to­ri­zar el registro de un servidor para buscar el acceso de una dirección IP concreta. Esto nos puede servir para de­te­r­mi­nar si el ataque a un servidor ya ha terminado o está todavía en curso. En este ejemplo mo­ni­to­ri­za­mos el registro de acceso del servidor web Apache para las entradas pro­ce­de­n­tes de la dirección IP ‘93.184.216.34’:

Veamos otro escenario común. En lugar de filtrar el registro de accesos en función de una dirección IP, mo­ni­to­ri­za­mos los accesos a un recurso concreto. Un acceso al archivo ‘robots.txt’ indica que los bots de los motores de búsqueda están so­li­ci­ta­n­do este recurso. De nuevo, vamos a utilizar el comando grep. Si queremos que muestre los nuevos accesos de los bots de motores de búsqueda, debemos eje­cu­tar­lo de esta manera: