Linux / Commande tail : dernières lignes et suivi des journaux

tail est une commande Linux utilisée pour vérifier la partie finale d'un fichier. Si elle est exécutée sans options, elle affiche les 10 dernières lignes. Vous pouvez spécifier le nombre de lignes avec -n et surveiller en continu les journaux nouvellement ajoutés avec -f ou -F.

Cette commande est particulièrement utile pour consulter les dernières entrées proches d’un incident ou pour observer les journaux d'un service en cours d'exécution. Dans cet article, nous expliquons les bases de la syntaxe, les méthodes de suivi en tenant compte de la rotation des journaux, le filtrage et la surveillance de plusieurs fichiers à l'aide d'exemples concrets.

Commande tail

tail affiche la dernière partie d'une entrée texte. Si aucun fichier n'est spécifié ou si - est utilisé à la place d'un fichier, il lit depuis l'entrée standard. La sortie est exprimée en lignes par défaut, et sans options spécifiques, il affiche les 10 dernières lignes.

Il est pratique pour vérifier la fin de gros fichiers journaux sans ouvrir le fichier entier. Cependant, tail n'est pas un outil pour analyser ou archiver les journaux ; c'est un outil pour lire la fin d'un fichier et suivre ses modifications.

Syntaxe de base et utilisation

La syntaxe de base est la suivante. Les crochets indiquent des éléments optionnels et ne doivent pas être inclus dans la commande réelle.

tail [options] [file...]

Par exemple, pour vérifier les 10 dernières lignes de /var/log/app.log, exécutez ce qui suit.

tail /var/log/app.log

Si vous avez besoin des 20 dernières lignes, spécifiez le nombre de lignes avec l'option -n.

tail -n 20 /var/log/app.log

Vous pouvez l'écrire de manière succincte comme -20, mais dans les scripts et les documents, le format less (en anglais) lisible -n 20 est plus clair.

Comment afficher uniquement la plage souhaitée

Afficher les N dernières lignes

-n N affiche N lignes depuis la fin du fichier. Il est utilisé pour vérifier les demandes récentes ou les erreurs sur une certaine plage.

tail -n 50 access.log

Si vous voulez lire la sortie page par page, vous pouvez la passer à less.

tail -n 500 access.log | less

Afficher de la Nième ligne jusqu'à la fin

Ajouter un signe plus avant le nombre -n +N a une signification différente. Au lieu d'afficher les N dernières lignes, il affiche à partir de la Nième ligne du fichier jusqu'à la fin.

tail -n +2 data.csv

Cet exemple ignore la première ligne physique. Il convient à un fichier CSV dont l’en-tête tient sur cette seule ligne. tail ne décode pas la structure CSV : une ligne physique n’est pas nécessairement un enregistrement si un champ contient un saut de ligne.

Sortie par octets au lieu de lignes

-c N affiche les N derniers octets au lieu des lignes. Vous pouvez utiliser des suffixes comme K ou M.

tail -c 1K output.bin

-c +N affiche à partir du Nième octet jusqu'à la fin. Si vous coupez par octets, un caractère multioctet peut être coupé en plein milieu, il est donc généralement plus sûr d'utiliser -n pour du texte multioctet.

Afficher en continu les journaux nouvellement ajoutés

Suivre en continu le fichier ouvert avec -f

-f affiche d'abord la fin du fichier, puis continue à montrer tout nouveau contenu ajouté au fichier. Le comportement par défaut suit le descripteur de fichier ouvert, ce qui le rend adapté aux situations où les journaux sont continuellement ajoutés au même fichier.

tail -f /var/log/app.log

Pour arrêter le suivi, appuyez sur Ctrl+C.

Gérer la rotation des journaux avec -F

Dans un environnement opérationnel, les fichiers journaux peuvent changer de nom et être remplacés par de nouveaux fichiers après avoir atteint une certaine taille ou période. Ceci s'appelle la rotation des journaux. -F de GNU tail est équivalent à --follow=name --retry, qui tente de rouvrir en fonction du nom de fichier.

tail -F /var/log/app.log

Par conséquent, lorsqu'on observe les journaux de service fréquemment soumis à rotation pendant une longue période, -F est souvent plus pratique que -f. Ce comportement peut être vérifié dans la documentation officielle de GNU Coreutils tail.

Afficher uniquement les nouveaux journaux sans le contenu existant

Si les 10 dernières lignes du contenu existant ne sont pas nécessaires lors de l'exécution de -f, utilisez -n 0 en même temps. Seules les lignes ajoutées après l'exécution de la commande seront affichées.

tail -n 0 -f /var/log/app.log

Options fréquemment utilisées

Avec GNU tail, l’option -s règle l’intervalle lorsque le suivi procède par vérifications périodiques. Si les notifications inotify du noyau sont utilisées, cet intervalle ne commande généralement pas l’arrivée des nouvelles lignes ; avec --pid, il sert aussi à vérifier si le processus existe encore.

La liste des options prises en charge peut varier en fonction du système d'exploitation et de l'implémentation tail. Surtout lors de l'utilisation de -F et --pid dans un script, il est recommandé de vérifier le support sur le système cible avec tail --help.

Exemples pratiques utiles pour vérifier les journaux

Trouver uniquement les erreurs récentes

Tout d'abord, lisez seulement les 200 dernières lignes, puis utilisez grep pour filtrer les chaînes d'erreurs afin de réduire le besoin de chercher dans de grands anciens journaux.

tail -n 200 app.log | grep 'ERROR'

Pour ignorer la casse, utilisez grep -i, et si les numéros de ligne sont nécessaires, utilisez grep -n. Attention : après tail -n 200, les numéros produits par grep -n correspondent au flux reçu, pas aux numéros de ligne du fichier d’origine.

Visualisation continue uniquement des nouvelles erreurs

Pour suivre uniquement les nouvelles lignes d’erreur, y compris après une rotation, associez tail -n 0 -F à GNU grep. L’option --line-buffered réduit l’attente liée à la mise en tampon du pipeline en transmettant chaque ligne dès qu’elle est disponible.

tail -n 0 -F app.log | grep --line-buffered 'ERROR'

Cette méthode ne fait que restreindre ce qui est affiché à l'écran et ne modifie pas le journal original. Si vous avez besoin de conditions multiples ou d'une analyse structurée des journaux, il est préférable de considérer des outils dédiés à la collecte et à la recherche de journaux.

Visualisation de plusieurs fichiers journaux simultanément

Vous pouvez spécifier plusieurs fichiers avec tail. Dans ce cas, un en-tête de nom de fichier est affiché afin que vous puissiez savoir de quel fichier provient la sortie.

tail -F access.log error.log

Pour rendre la sortie de chaque fichier plus distincte, ajoutez -v, et si l'en-tête est inutile, utilisez -q.

Arrêter le suivi à la fin du processus producteur

Avec GNU tail, --pid arrête le suivi quand le processus indiqué se termine. L’exemple complet suivant nécessite Bash et une version de GNU tail prenant en charge --pid. Il crée un répertoire temporaire dans le répertoire courant, produit trois lignes, affiche le journal et récupère le code de sortie du producteur. $! fournit l’identifiant du dernier processus lancé en arrière-plan.

demo_dir=$(mktemp -d ./tail-demo.XXXXXX) || exit 1
: > "$demo_dir/build.log"
(
    for step in 1 2 3; do
        printf 'étape %s\n' "$step"
        sleep 1
    done
) >> "$demo_dir/build.log" 2>&1 &
writer_pid=$!
tail -n +1 --pid="$writer_pid" -f "$demo_dir/build.log"
wait "$writer_pid"
writer_status=$?
printf 'Code de sortie : %s\n' "$writer_status"
rm -- "$demo_dir/build.log"
rmdir -- "$demo_dir"

Le résultat attendu est étape 1, étape 2, étape 3, puis Code de sortie : 0. Le suivi se termine après l’arrêt du producteur.

La détection de fin par --pid peut prendre un court délai. La commande wait permet de récupérer le code de sortie du producteur ; ne le confondez pas avec celui de tail. L’exemple supprime ensuite le fichier et le répertoire temporaires qu’il a créés.

La différence entre -f et -F

-F n'est pas toujours meilleur. Dans des cas particuliers où un processus continue d'écrire dans un fichier existant dont le nom a changé, garder le fichier ouvert avec -f peut mieux montrer ce qui est nécessaire. Le choix doit se baser sur la méthode de génération des journaux et la politique de rotation.

Quand tail n'est pas approprié

• Journal Systemd : Si les journaux sont stockés dans le journal plutôt que sous forme de fichiers texte simples, utilisez journalctl -f. Pour des services spécifiques, vous pouvez affiner avec journalctl -f -u service_name.
• Vérification du début : Pour les premières lignes d'un fichier, head est plus simple.
• Lecture avec navigation dans l’historique : Pour vérifier à la fois le contenu passé et nouveau, less +F filename peut être pratique. Arrêtez le suivi avec Ctrl+C, déplacez-vous vers le haut et le bas, et reprenez le suivi avec F.
• Mise à jour périodique des résultats de commande : Si vous voulez vérifier à plusieurs reprises les derniers résultats d'une commande plutôt que des parties supplémentaires d'un fichier, utiliser la commande Linux watch (en anglais) est mieux adapté à cet usage.
• Journaux centraux à grande échelle : Si vous avez besoin de rechercher, d'agréger et de recevoir des alertes sur les journaux de plusieurs serveurs sur une longue période, un système de journalisation centralisé ou un outil d'observabilité est nécessaire.

Points à considérer concernant les permissions et l'environnement d'exploitation

Erreurs de permission refusée

Si vous n'avez pas la permission de lecture pour le fichier journal, une erreur Permission denied se produira. Vérifiez d'abord le propriétaire et les permissions avec ls -l filename, et demandez en toute sécurité les permissions nécessaires à l'administrateur. Évitez d'élargir les permissions de manière indiscriminée ou de préfixer chaque commande avec sudo.

Sortie de journal sensible

Les jetons d'authentification, les identifiants de session et les informations personnelles peuvent être inclus dans les journaux. Assurez-vous que les valeurs sensibles ne sont pas exposées dans les partages d'écran, les historiques de terminal ou les messages d'erreur copiés. Lors du partage de journaux opérationnels à l'extérieur, extrayez uniquement le périmètre nécessaire et anonymisez les valeurs sensibles.

Questions fréquemment posées

Combien de lignes tail affiche-t-il par défaut ?

Si aucune option n'est spécifiée, il affiche les 10 dernières lignes. Si vous avez besoin d'un nombre différent, vous pouvez spécifier le nombre de lignes après -n, par exemple tail -n 30 filename.

Comment arrêter tail -f ?

Appuyez sur Ctrl+C pour arrêter le suivi en cours et revenir à l'invite du shell. Cette action ne supprime ni ne modifie le fichier journal.

Pourquoi ne vois-je pas de nouveau contenu après la rotation des journaux ?

Cela peut être dû au fait que -f continue de suivre le descripteur du fichier avant qu'il ne soit remplacé. Essayez d'utiliser GNU tail -F filename pour rouvrir le nouveau fichier en fonction du nom de fichier. S'il n'apparaît toujours pas, vous devez vérifier le chemin réel du journal et les paramètres de sortie du service.

Peut-on utiliser tail sur des fichiers journaux compressés ?

tail ne décompresse pas automatiquement les formats compressés. Vous pouvez décompresser le fichier compressé entier et le passer par un pipe, mais cela peut être inefficace pour les fichiers volumineux. Par exemple, un fichier gzip peut être vérifié avec zcat archive.log.gz | tail -n 50.

Résumé

Pour vérifier rapidement le contenu récent, utilisez tail filename, et pour spécifier le nombre de lignes, utilisez tail -n N filename. Pour visualiser continuellement les nouveaux journaux, utilisez -f, et si le fichier est remplacé en raison de la rotation des journaux, il est recommandé d'utiliser -F de GNU tail.

En combinant tail avec grep, vous pouvez filtrer uniquement les messages nécessaires, mais soyez prudent avec les permissions et l'exposition des informations sensibles.