Commande tail de Linux

La commande tail de Linux est l’un des outils essentiels de l’interface en ligne de commande. La fonction principale de cette commande est d’afficher la fin d’un fichier (texte), autrement dit de limiter la sortie d’une commande Linux à un certain nombre de lignes. La commande tail fait donc partie d’une série qui inclut la commande head de Linux et les commandes 'cat' et 'less'. Les commandes Linux servent toutes à afficher le contenu de fichiers texte.

La commande tail de Linux appartient aux utilitaires de base (Coreutils) GNU. Il s’agit d’une collection de commandes de base pour l’interface en ligne de commande qui sont incluses dans le système de commande open source Linux. Les Coreutils sont publiés sous licence open source et sont disponibles en téléchargement pour une variété de systèmes d’exploitation différents.

Raison d’être de la commande tail de Linux

La fonction élémentaire de la commande tail de Linux est d’afficher la fin d’un fichier. Il faut savoir que les données écrites dans un fichier se retrouvent à la fin du fichier. La commande tail de Linux permet par conséquent de vérifier si de nouvelles données ont été ajoutées à un fichier. C’est pourquoi elle est appréciée pour analyser les fichiers log.

De nombreux programmes, notamment les serveurs Web comme Apache ou nginx, écrivent des informations d’état dans ce que l’on appelle des fichiers journaux. Dans le cas des journaux de serveur, les fichiers contiennent, entre autres, un horodatage, l’URL de la ressource demandée et l’adresse IP de la partie requérante.

Les fichiers journaux s’agrandissent à chaque requête et deviennent de plus en plus volumineux. Pour limiter leur taille au-delà d’un certain point, les fichiers journaux font habituellement l’objet d’un « roulement ». Le fichier journal est compressé et archivé sous un nouveau nom, et un nouveau fichier journal vide est créé sous le nom d’origine. Voici un aperçu des fichiers journaux courants sous Ubuntu Linux :

Fichier journal Ubuntu Linux Explication
/var/log/auth.log Journal d’autorisation Linux
/var/log/daemon.log Journal du daemon Linux
/var/log/debug Journal de débogage Linux
/var/log/kern.log Journal du noyau Linux
/var/log/syslog Journal du système Linux
/var/log/apache2/access.log Accès aux contenus du serveur Web Apache2
/var/log/apache2/error.log Messages d’erreur du serveur Web Apache2

Appel de la commande tail de Linux dans l’interface en ligne de commande

La commande tail de Linux est appelée dans l’interface en ligne de commande. Comme il est d’usage, le nom de la commande est saisi, suivi de paramètres facultatifs. La séquence se termine par le nom ou le chemin d’un ou de plusieurs fichiers. Pour commencer, voyons comment écrire un cas général :

tail [options] <fichiers>

Sans options, la séquence la plus simple de la commande tail de Linux est la suivante :

tail <fichier>

Appelée de cette manière, la commande tail de Linux affiche les dix dernières lignes du fichier spécifié. C’est utile pour visualiser les données les plus récentes écrites dans le fichier.

Options de base de la commande tail de Linux

La commande tail de Linux peut être contrôlée par des paramètres. Les Coreutils comprennent une forme longue pour chaque option et une forme abrégée pour les options les plus fréquemment utilisées. Le tableau ci-dessous donne un aperçu des options les plus utiles :

Option (forme abrégée/forme longue) Explication
-n / --lines Limiter la sortie aux dernières lignes n/limiter la sortie aux lignes suivantes à partir de la ligne n 
-c / --bytes Limiter la sortie aux derniers octets n/limiter la sortie aux octets suivants à partir de l’octet n 
-q / --quiet, --silent Supprimer la sortie des noms de fichiers lorsqu’il y a plusieurs fichiers
-v / --verbose Forcer la sortie des noms de fichiers lorsqu’il y a plusieurs fichiers
--help Afficher les informations d’aide de la commande
--version Afficher les informations sur la version de la commande
Note

La commande tail de Linux est conçue avant tout pour traiter les fichiers texte utilisant le jeu de caractères ASCII. Un caractère correspond alors exactement à un octet. Si vous manipulez des fichiers en Unicode avec l’option '-c' de la commande tail de Linux, des effets secondaires inattendus pourraient survenir.

Options avancées de la commande tail de Linux

Les options de base de la commande tail de Linux présentées précédemment fonctionnent de manière identique à celles de la commande head. À ceci près que la commande head affiche le début d’un fichier, tandis que tail en affiche la fin. Mais la commande tail peut aller beaucoup plus loin.

En particulier, elle fournit de multiples options pour suivre les modifications apportées aux fichiers. Avec la commande tail de Linux, les données ajoutées à la fin du fichier peuvent être affichées en continu. Il s’ensuit que tail est particulièrement adaptée au suivi des fichiers journaux. Ce processus est connu sous le nom de « live tail » (« queue en direct » en français). Voici un aperçu des options les plus couramment utilisées :

Option (forme abrégée/forme longue) Explication
-f / --follow=[{name|descriptor}] Surveiller les modifications du fichier et afficher en continu les nouvelles données écrites à la fin du fichier. Sans spécifier de valeur après '--follow=', 'descriptor' est utilisé comme valeur par défaut. Cela signifie que la live tail continuera même si le fichier est renommé ou déplacé.
-F Correspond à l’appel avec --follow=name –retry ; l’effet est que la live tail continue même si le fichier original est supprimé dans le cadre du roulement du journal et remplacé par un nouveau fichier portant le même nom.
-s / --sleep-interval=N Suspendre la sortie pendant le nombre de secondes spécifié.
--retry Essayer de rouvrir un fichier indisponible dès qu’il redevient disponible. Très pratique en combinaison avec l’option '--follow=name' pour continuer à surveiller le nouveau fichier du même nom après le roulement d’un fichier journal.
--pid=PID Lorsqu’elle est utilisée avec l’option -f, la commande tail prend fin quand le processus portant l’ID de processus spécifié se termine. Utile pour interrompre la live tail lorsque le programme qui écrit dans le fichier prend fin.

Exemples d’utilisation de la commande tail de Linux

Dans la documentation des Coreutils, la commande tail de Linux figure dans la section « Output of parts of files » (sortie de parties de fichiers). Le terme « fichiers » s’entend ici au sens large. « Flux de texte » serait plus exact.

Conformément à la philosophie Unix, les commandes de l’interface en ligne de commande utilisent les flux de texte comme format universel d’entrée et de sortie. Les flux de texte sont surtout des fichiers, mais aussi des entrées et sorties standard de la ligne de commande. Par ailleurs, les « pipes » (« tubes » en français) revêtent une grande importance. En effet, ils permettent d’enchaîner plusieurs commandes. La sortie d’une commande est alors transférée comme entrée à la commande suivante.

L’idée d’enchaîner plusieurs commandes découle de la philosophie Unix. Plutôt que de développer des commandes complexes pour des tâches entièrement différentes, il existe un ensemble relativement succinct de commandes générales. Suivant la devise « Fais une chose et fais-la bien », chaque commande a une fonctionnalité étroitement délimitée. Les commandes utilisent les flux de texte comme interface universelle et peuvent être combinées pour créer des solutions toujours nouvelles.

Note

Dans les exemples suivants, quand nous appelons la commande tail de Linux, nous utilisons les options dans leur forme abrégée ('-n' au lieu de '--lines', etc.). Vous rencontrerez souvent cet usage lorsque vous lirez d’autres documentations ou exemples de code.

Exemples généraux d’utilisation de la commande tail de Linux

Les exemples généraux suivants utilisent les options de base de la commande tail de Linux présentées au début. Pour des exemples d’utilisation des options avancées, lisez la partie sur la surveillance des fichiers journaux ci-dessous.

La plupart des exemples combinent la commande tail à une ou à plusieurs autres commandes Linux. Les pipes susmentionnés servent à reprendre la sortie d’une commande comme entrée de la commande suivante.

Sortir la fin d’un fichier à l’aide de la commande tail de Linux

Dans le cas le plus simple, on utilise la commande tail de Linux pour sortir les dernières lignes d’un fichier. Pour l’essayer, remplacez le caractère générique '<fichier>' par le nom ou le chemin d’un fichier texte présent sur votre système. Ici, nous utilisons l’option -n et nous sortons les trois dernières lignes d’un fichier :

tail -n 3 <fichier>

Il est souvent utile de garder à l’esprit le contexte du fichier traité avec la commande tail. Pour sortir les lignes avec des numéros de ligne, nous traitons d’abord le fichier avec la commande nl (qui signifie « line numbering », soit « numérotation de ligne »), et nous transférons la sortie à la commande tail à l’aide d’un pipe :

nl <fichier> | tail -n 3

Sortir les dernières commandes utilisées dans la ligne de commande

La commande history affiche les commandes saisies dans la ligne de commande. Ce sont souvent les derniers appels qui ont un intérêt. De surcroît, une sortie complète de l’historique des commandes pourrait révéler des données sensibles. Ici, nous transférons la sortie de la commande history à la commande tail et nous sortons les cinq dernières lignes :

history | tail -n 5

Supprimer les plus anciens fichiers de sauvegarde d’un répertoire avec la commande tail

Voyons maintenant un exemple plus complexe. Nous allons supprimer les dix fichiers les plus anciens d’un répertoire contenant des fichiers de sauvegarde. Pour ce faire, nous utilisons les quatre commandes Linux 'ls', 'tail', 'xargs' et 'rm' :

ls -t *.bak | tail | xargs rm

Que se passe-t-il exactement ici ?

  1. La commande ls liste les fichiers du répertoire.

Avec l’option '-t', les fichiers sont triés par date de modification. Les fichiers les plus anciens se retrouvent en bas de la liste.

Nous employons le schéma de recherche '*.bak' pour la source de données. Il s’agit d’une extension de fichier courante pour les fichiers de sauvegarde. C’est, de plus, un moyen de se protéger afin d’éviter une suppression accidentelle de fichiers importants.

Nous transférons la liste des fichiers à la commande tail à l’aide d’un pipe.

  1. En utilisant la commande tail sans indiquer d’options, nous sortons les dix derniers fichiers de la liste. Les noms de fichier affichés sont les fichiers les plus anciens du répertoire.
  2. La commande xargs récupère la liste de fichiers et le nom de la commande. La commande est exécutée et les fichiers sont transmis comme arguments.

Dans notre exemple, la commande tail de Linux renvoie un texte de plusieurs lignes. Chaque ligne contient le nom d’un fichier à supprimer. À l’aide de 'xargs', les noms de fichier sont dissociés des lignes et transmis comme arguments à la commande rm.

  1. Pour supprimer des fichiers sous Linux, on recourt à la commande rm. Celle-ci supprime les fichiers transmis comme arguments.

Veillez à ce que les fichiers ne soient pas déplacés dans la corbeille et aussitôt supprimés.

La prudence est de rigueur quand il est question de supprimer des fichiers dans la ligne de commande Linux. Pour mettre en pratique notre exemple sans craindre pour vos données, nous vous conseillons de créer au préalable un répertoire avec des fichiers de test. À cette fin, exécutez le code suivant dans l’interface en ligne de commande :

mkdir ~/Bureau/tail-test/
cd ~/Bureau/tail-test/
touch test-{1..100}.bak

Pour commencer, nous créons un répertoire de test nommé 'tail-test/' sur le bureau et nous accédons à ce répertoire. Ensuite, nous créons 100 fichiers de test vides, 'test-1.bak' à 'test-100.bak'. Lorsque c’est fait, nous exécutons le code pour supprimer les dix fichiers les plus anciens :

ls -t ~/Bureau/tail-test/*.bak | tail | xargs rm

Surveiller les modifications de fichiers journaux de serveur avec la commande tail de Linux

Jusqu’ici, nous avons vu simplement le fonctionnement général de la commande tail de Linux. Dans les exemples suivants, nous nous penchons sur le suivi en direct de fichiers journaux de serveur (« live tail »).

Dans ces exemples, nous imaginons qu’il s’agit d’un serveur Web Apache2 sous Ubuntu Linux. Les fichiers journaux se trouvent dans le répertoire '/var/log/apache2/'. L’emplacement peut différer sur les autres distributions Linux. Il en va de même pour les autres serveurs Web, tels que nginx.

Note

Il se peut que seul l’utilisateur racine ait accès au répertoire contenant les fichiers journaux. Dans ce cas, il faut exécuter les commandes avec 'sudo'.

Surveiller les modifications d’un fichier journal de serveur avec la commande tail de Linux

Un appel normal de la commande tail affiche une fois seulement le nombre de lignes spécifié d’un fichier. Si de nouvelles données sont ajoutées à la fin du fichier par la suite, il est nécessaire d’exécuter à nouveau la commande. Mais il existe des options avancées pour ce cas précis. Elles permettent de surveiller les modifications d’un fichier et de les sortir en continu.

Voyons comment cela fonctionne en prenant pour exemple le journal d’accès du serveur Web Apache2. Nous appelons la commande tail de Linux avec l’option -f et transmettons le nom du fichier journal :

tail -f /var/log/apache2/access.log

Les modifications apportées au journal d’accès sont ainsi affichées en continu. Cependant, cette méthode n’est pas pratique lorsqu’il y a beaucoup d’accès par unité de temps. Dans ce cas, le journal change si rapidement que le terminal est inondé de données. Appuyez sur le raccourci 'Ctrl+C' pour annuler l’exécution de la live tail.

Appelée avec l’option '-f', la commande tail de Linux surveille le fichier spécifié. Si elle est supprimée, la sortie est interrompue. Comme expliqué plus haut, les fichiers journaux font l’objet d’un roulement périodique. Un nouveau fichier est donc créé sous l’ancien nom. Pour continuer à suivre un fichier journal malgré le roulement, il faut employer l’option -F :

tail -F /var/log/apache2/access.log

Surveiller les modifications de plusieurs fichiers journaux de serveur avec la commande tail de Linux

Pour l’instant, nous avons utilisé la commande tail de Linux pour traiter seulement un fichier. Or, cette commande permet également de surveiller plusieurs fichiers en même temps. À cet effet, nous utilisons le schéma de recherche '*.log' pour suivre en continu tous les fichiers portant l’extension '.log' :

tail -F /var/log/apache2/*.log

Il existe deux autres possibilités pour traiter plusieurs fichiers. On peut d’une part utiliser l’option '-q' pour supprimer la sortie des noms de fichier :

tail -q -F /var/log/apache2/*.log

De même, l’option -v peut être utilisée pour forcer la sortie des noms de fichier. C’est judicieux si le schéma de recherche ne renvoie qu’un seul fichier :

tail -v -F /var/log/apache2/*.log

Surveiller des modifications particulières d’un fichier journal de serveur avec la commande tail de Linux

Dans les exemples précédents, nous avons surveillé un fichier journal en vue de suivre n’importe quelle modification. En réalité, il est plus répandu de restreindre cette fonction à certaines modifications. Pour limiter l’affichage des modifications d’un fichier journal à un schéma de recherche, il faut recourir à la commande grep. Voici un exemple général de cette méthode :

tail -F /var/log/apache2/access.log | grep <muster>

Dans les faits, il est souvent intéressant de surveiller un journal de serveur pour détecter les accès par une adresse IP particulière. Cela peut s’avérer utile par exemple pour déterminer si une attaque contre un serveur est terminée ou toujours en cours. Ici, nous surveillons le journal d’accès d’un serveur Web Apache concernant les requêtes provenant de l’adresse IP '93.184.216.34' :

tail -F /var/log/apache2/access.log | grep '93.184.216.34'
Note

Nous utilisons ici l’adresse IP du domaine fictif 'exemple.com'. Si un journal d’accès la contient réellement, il s’agit très certainement d’une adresse IP usurpée.

Examinons un autre cas de figure fréquent. Au lieu de filtrer le journal d’accès par adresse IP, nous surveillons les accès à une ressource spécifique. Un accès au fichier 'robots.txt' indique une requête provenant d’un robot d’indexation de moteur de recherche. Là encore, nous avons recours à la commande grep. Avec cette commande, seuls les nouveaux accès entrants des robots sont affichés :

tail -F /var/log/apache2/access.log | grep 'robots.txt'
Cet article vous a-t-il été utile ?