Comando tail di Linux

Il comando tail di Linux è uno degli strumenti es­sen­zia­li della riga di comando. Prin­ci­pal­men­te, il comando è usato per mostrare la fine di un file (di testo) o per limitare l’output di un comando Linux a un de­ter­mi­na­to ambito. Questo mette il comando tail di Linux in linea con il comando head di Linux e i comandi ‘cat’ e ‘less’. I pre­ce­den­ti comandi di Linux sono tutti usati per mostrare il contenuto dei file di testo.

Il comando tail di Linux fa parte delle GNU Core Utilities (Coreutils). È una raccolta di comandi di base per la riga di comando, che sono inclusi nel sistema operativo open source di Linux. Le coreutils sono ri­la­scia­te con una licenza open source e sono di­spo­ni­bi­li per il download per una varietà di sistemi operativi diversi.

La fun­zio­na­li­tà di base del comando tail di Linux è quella di vi­sua­liz­za­re la fine di un file. Per fare questo, dovete sapere che i dati scritti in un file finiscono alla fine del file. Così il comando tail di Linux ci permette di con­trol­la­re se sono stati aggiunti nuovi dati a un file. Pertanto, il comando tail di Linux è co­mu­ne­men­te uti­liz­za­to per ana­liz­za­re i file di log e mo­ni­to­rar­li.

Molti programmi, spe­cial­men­te server web come Apache o nginx scrivono in­for­ma­zio­ni di stato nei co­sid­det­ti file di log. Nel caso dei log del server, questi file con­ten­go­no, per ogni riga, una marca temporale, l’URL della risorsa richiesta, l’indirizzo IP del ri­chie­den­te e altre in­for­ma­zio­ni. Crescono pro­gres­si­va­men­te a ogni richiesta e, per limitare le di­men­sio­ni oltre una certa soglia, i file di log sono di solito “ruotati”. Vengono compressi e ar­chi­via­ti con un nuovo nome. Inoltre, viene creato un nuovo file di log vuoto con il nome originale. Il­lu­stria­mo di seguito una pa­no­ra­mi­ca dei comuni file di log sotto Ubuntu Linux:

Il comando tail di Linux viene eseguito sulla riga di comando. Come al solito, si inserisce il nome del comando seguito da parametri opzionali e infine si aggiunge il nome o il percorso di uno o più file. Per prima cosa, guardiamo la notazione del caso generale:

Senza opzioni, il richiamo più semplice del comando tail di Linux è rap­pre­sen­ta­to dal seguente schema:

Ri­chia­ma­to in questo modo, il comando tail di Linux mostra le ultime dieci righe del file spe­ci­fi­ca­to. Questo è utile per vi­sua­liz­za­re i dati più recenti scritti nel file.

Il comando tail di Linux può essere con­trol­la­to da parametri. Come parte delle GNU Coreutils, c’è una forma lunga per ogni opzione. C’è anche una forma breve per le opzioni usate più co­mu­ne­men­te, spesso motivate sto­ri­ca­men­te. Il­lu­stria­mo di seguito una pa­no­ra­mi­ca delle opzioni più utili:

Le opzioni di base del comando tail di Linux descritte sopra fun­zio­na­no ana­lo­ga­men­te al comando head. Tuttavia, mentre il comando head mostra l’inizio del file, il comando tail di Linux mostra la fine. Ma il comando può essere usato in molti altri modi e, nello specifico, offre svariate opzioni per mo­ni­to­ra­re modifiche ai file. Con questo comando, i dati aggiunti alla fine del file possono essere vi­sua­liz­za­ti con­ti­nua­men­te. Pertanto, è par­ti­co­lar­men­te adatto al mo­ni­to­rag­gio dei file di log. Questo processo è anche noto come “live tail”. Il­lu­stria­mo di seguito una pa­no­ra­mi­ca delle opzioni più co­mu­ne­men­te usate:

Nella do­cu­men­ta­zio­ne di coreutils, il comando tail di Linux è riportato nella sezione “Output of parts of files” (Vi­sua­liz­za­zio­ne di parti di file). Dovete sapere che il termine “file” è molto ampio. Più preciso è il termine “flussi di testo”.

Seguendo la filosofia Unix, i comandi da riga di comando usano flussi di testo come formato uni­ver­sa­le di input e output. I flussi di testo sono so­prat­tut­to file, ma anche input e output standard della riga di comando. Inoltre, le co­sid­det­te “pipe”, che in italiano significa all’incirca “tubi”, sono di grande im­por­tan­za. Queste per­met­to­no di con­ca­te­na­re più comandi. In questo caso, l’output di un comando viene passato come input al comando suc­ces­si­vo.

L’idea di fondo di con­ca­te­na­re diversi comandi insieme risale alla filosofia Unix. Invece di svi­lup­pa­re comandi complessi per compiti com­ple­ta­men­te diversi, c’è un insieme re­la­ti­va­men­te gestibile di comandi generali. Seguendo la massima “do one thing, and do it well” (“fai una cosa e falla bene”), ogni comando ha una fun­zio­na­li­tà stret­ta­men­te definita. I comandi uti­liz­za­no i flussi di testo come in­ter­fac­cia uni­ver­sa­le e possono essere combinati per creare soluzioni sempre nuove.

I seguenti esempi generali usano le opzioni di base del comando tail di Linux pre­sen­ta­te all’inizio. Per gli esempi che usano le opzioni avanzate, potete con­sul­ta­re il paragrafo sul mo­ni­to­rag­gio dei file di log che trovate più avanti. La maggior parte degli esempi il­lu­stra­ti combinano il comando tail di Linux con uno o più altri comandi di Linux. Le pipe sopra men­zio­na­te si impiegano per uti­liz­za­re l’output di un comando come input del comando suc­ces­si­vo.

Nel caso più semplice, usiamo il comando tail di Linux per mostrare le ultime righe di un file. Per provarlo, so­sti­tui­te il se­gna­po­sto ‘<file>‘ con il nome o il percorso di un file di testo presente sul vostro sistema. Di seguito usiamo l’opzione -n e vi­sua­liz­zia­mo le ultime tre righe di un file:

È spesso utile tenere sotto controllo il contesto del file elaborato dal comando tail di Linux. Per vi­sua­liz­za­re le righe con i numeri di riga, prima ela­bo­ria­mo il file con il comando nl (il nome deriva da “line numbering”, ovvero “numeri di riga”) e in­stra­dia­mo l’output tramite pipe al comando tail di Linux:

Il comando history vi­sua­liz­za i comandi inseriti sulla riga di comando. Spesso si è in­te­res­sa­ti solo alle ultime chiamate. Inoltre, un output completo della cro­no­lo­gia dei comandi può rivelare dati sensibili. In questo esempio in­stra­dia­mo l’output del comando history al comando tail di Linux e vi­sua­liz­zia­mo le ultime cinque righe:

Vediamo un esempio più complesso. Can­cel­le­re­mo i dieci file più vecchi da una directory con file di backup. Per fare questo, usiamo i quattro comandi Linux ‘ls’, ‘tail’, ‘xargs’ e ‘rm’:

Cosa succede esat­ta­men­te?

1. Il comando ls elenca i file presenti in una directory.

Con l’opzione ‘-t’, i file vengono ordinati per data di modifica. I file più vecchi sono in fondo alla lista.

Usiamo il motivo di ricerca ‘*.bak’ per l’origine dati. In pratica, si tratta di un’esten­sio­ne co­mu­ne­men­te uti­liz­za­ta per i file di backup. Inoltre, serve come pro­te­zio­ne in modo da non can­cel­la­re ac­ci­den­tal­men­te i file im­por­tan­ti quando li ri­chia­ma­te.

Tra­smet­tia­mo tramite pipe l’elenco dei file al comando tail di Linux.

1. Usando il comando tail di Linux senza spe­ci­fi­ca­re alcuna opzione, leggiamo gli ultimi dieci file dell’elenco. I nomi dei file di output sono i file più vecchi della directory.
2. Il comando xargs riceve una lista di file e il nome di un comando. Il comando viene eseguito passando i file come argomenti.

Nel nostro esempio, il comando tail di Linux re­sti­tui­sce un testo con più righe. Ogni riga contiene il nome di un file da can­cel­la­re. Tramite ‘xargs’ i nomi dei file sono staccati dalle righe e trasmessi come argomenti al comando rm.

1. Per can­cel­la­re i file sotto Linux, si ricorre al comando rm. Questo comando cancella i file trasmessi come argomenti.

Si noti che i file non vengono spostati nel cestino, ma can­cel­la­ti im­me­dia­ta­men­te.

È con­si­glia­bi­le fare at­ten­zio­ne quando si procede alla can­cel­la­zio­ne dei file sulla riga di comando di Linux. Affinché possiate provare il nostro esempio senza pre­oc­cu­pa­zio­ni, dovreste prima creare una directory con dei file di prova. Per farlo, eseguite il seguente codice sulla riga di comando:

Per prima cosa, creiamo una directory di prova ‘tail-test/’ sul desktop e passiamo a quella directory. Poi creiamo 100 file di prova vuoti con i nomi da ‘test-1.bak’ a ‘test-100.bak’. Quindi eseguite il codice per can­cel­la­re i dieci file più vecchi:

Finora abbiamo visto il fun­zio­na­men­to generale del comando tail di Linux. Negli esempi seguenti, ci con­cen­tria­mo sul mo­ni­to­rag­gio dal vivo dei file di log del server (“live tail”).

In questi esempi, partiamo dal server web Apache2 su Ubuntu Linux. I file di log si trovano nella directory ‘/var/log/apache2/’. Su altre di­stri­bu­zio­ni Linux, il percorso potrebbe essere diverso. Lo stesso vale per altri server web, come nginx.

Una normale chiamata al comando tail di Linux vi­sua­liz­za una volta il numero spe­ci­fi­ca­to di righe di un file. Se in seguito vengono aggiunti nuovi dati alla fine del file, il comando deve essere eseguito di nuovo. Esat­ta­men­te per questo caso ci sono altre opzioni. Queste istrui­sco­no il comando a mo­ni­to­ra­re le modifiche a un file e a mostrarle con­ti­nua­men­te.

Vediamo come funziona usando il log di accesso al server web Apache2 come esempio. Eseguiamo il comando tail di Linux con l’opzione -f e passiamo il nome del file di log:

Quando viene chiamato in questo modo, le modifiche al log di accesso vengono vi­sua­liz­za­te con­ti­nua­men­te. Questo approccio non è pratico in caso di numerosi accessi per unità di tempo. In questo caso, il registro cambia così ra­pi­da­men­te che il terminale viene inondato di dati. Premete la com­bi­na­zio­ne di tasti ‘Ctrl+C’ per annullare l’attuale ese­cu­zio­ne della live tail.

Ri­chia­ma­to con l’opzione ‘-f’, il comando tail di Linux controlla il file spe­ci­fi­ca­to. Se questo viene rimosso, l’output viene in­ter­rot­to. Come spiegato all’inizio, i file di log vengono ruotati pe­rio­di­ca­men­te. Viene quindi creato un nuovo file con il vecchio nome. Per con­ti­nua­re a mo­ni­to­ra­re un file di log no­no­stan­te la rotazione, usiamo l’opzione -F:

Finora abbiamo usato il comando tail di Linux per elaborare un singolo file. Tuttavia, il comando permette anche di mo­ni­to­ra­re più file con­tem­po­ra­nea­men­te. Di seguito usiamo lo schema di ricerca ‘*.log’ per mo­ni­to­ra­re con­ti­nua­men­te tutti i file con esten­sio­ne ‘.log’:

Ci sono altre due opzioni per elaborare più file. Per prima cosa, possiamo usare l’opzione ‘-q’ per sop­pri­me­re l’output dei nomi dei file:

Allo stesso modo, l’opzione -v può essere usata per forzare l’output dei nomi dei file, il che ha senso se lo schema di ricerca re­sti­tui­sce solo un singolo file:

Negli esempi pre­ce­den­ti, abbiamo mo­ni­to­ra­to qualsiasi modifica a un file di log. Più comune, tuttavia, è la re­stri­zio­ne a certe modifiche. Per limitare l’output delle modifiche di un file di log a uno schema di ricerca, si usa il comando grep. È il­lu­stra­to di seguito un esempio generale di questo approccio:

In par­ti­co­la­re, è spesso utile mo­ni­to­ra­re un log del server per gli accessi da un par­ti­co­la­re indirizzo IP. Questo può essere efficace, ad esempio, per de­ter­mi­na­re se un attacco a un server è già stato com­ple­ta­to o è ancora in corso. In questo esempio mo­ni­to­ria­mo il log di accesso del server web Apache per le richieste pro­ve­nien­ti dall’indirizzo IP ‘93.184.216.34’:

Guardiamo un altro scenario di di­stri­bu­zio­ne comune. Invece di filtrare il log di accesso per indirizzo IP, mo­ni­to­ria­mo gli accessi a una risorsa specifica. Un accesso al file ‘robots.txt’ indica le richieste dei bot dei motori di ricerca. Di nuovo, facciamo uso del comando grep. Eseguendo la chiamata in questo modo, vengono vi­sua­liz­za­ti solo i nuovi accessi dai bot dei motori di ricerca: