Suivre un log en temps réel sous Linux

Quand un service plante ou se comporte bizarrement, la première réflexe est d’ouvrir ses logs. Mais si vous ouvrez un fichier statique, vous voyez une photo. Ce qu’il vous faut, c’est un flux en direct — voir les lignes qui arrivent au moment où elles arrivent, filtrer les erreurs pendant qu’un déploiement se déroule, surveiller plusieurs fichiers simultanément.

Sous Linux, deux outils couvrent ce besoin : tail -f pour les fichiers plats, journalctl -f pour les journaux systemd. Ce guide vous montre comment les utiliser seuls et en combinaison.

Ce que vous allez apprendre

Suivre un fichier de log en temps réel avec tail -f et --follow=name
Filtrer les erreurs en temps réel dans un pipeline avec grep --line-buffered
Observer plusieurs fichiers à la fois avec tail -f
Interroger journalctl par unité, priorité, plage horaire ou démarrage
Choisir le bon outil selon la source du log

Dans quel contexte ?

Vous déployez une nouvelle version d’une application et vous voulez voir les logs au moment où le service redémarre. Un cron s’exécute la nuit et vous soupçonnez une erreur que vous n’arrivez pas à reproduire dans la journée. Un service est intermittent et vous voulez être alerté dès que ERROR apparaît, sans lancer une commande toutes les 30 secondes. La surveillance de logs en temps réel est une compétence de premier recours en administration système — elle vous donne les informations au bon moment, pendant l’événement, pas après.

`tail` — suivre des fichiers plats

Les bases

tail affiche les dernières lignes d’un fichier. Sans option, il en affiche 10 :

tail /var/log/syslog              # 10 dernières lignes
tail -n 50 /var/log/syslog        # 50 dernières lignes
tail -n +100 /var/log/syslog      # à partir de la ligne 100

Mode suivi : `tail -f`

-f (follow) ouvre le fichier et affiche les nouvelles lignes au fur et à mesure qu’elles sont écrites. Il ne rend pas la main — il reste actif jusqu’à Ctrl+C :

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

`tail -f` vs `tail --follow=name`

C’est une distinction importante en production :

Option	Comportement
`tail -f`	Suit le descripteur de fichier — s’arrête si le fichier est renommé (rotation)
`tail --follow=name --retry`	Suit le nom du fichier — survit à la rotation logrotate

# Pour les logs avec rotation (nginx, apache, syslog...)
tail --follow=name --retry /var/log/nginx/access.log

Suivre plusieurs fichiers

tail -f accepte plusieurs arguments. Il les préfixe avec le nom du fichier :

tail -f /var/log/nginx/access.log /var/log/nginx/error.log

==> /var/log/nginx/access.log <==
192.168.1.10 - - [09/Apr/2026:10:05:00] "GET /api/users HTTP/1.1" 200 523

==> /var/log/nginx/error.log <==
2026/04/09 10:05:01 [error] 1234#0: upstream timed out

Filtrer en temps réel

`grep --line-buffered` : l’option indispensable

Dans un pipeline normal, grep accumule sa sortie dans un tampon avant de l’écrire — ce qui casse l’effet temps réel. --line-buffered force l’écriture ligne par ligne :

# Ne montrer que les erreurs et avertissements
tail -f /var/log/app.log | grep --line-buffered -iE 'error|warn'

# Exclure les requêtes de monitoring (/health, /metrics)
tail -f /var/log/nginx/access.log | grep --line-buffered -v '/health\|/metrics'

# Afficher les erreurs HTTP 5xx avec couleur
tail -f /var/log/nginx/access.log | grep --line-buffered --color=always '" 5[0-9][0-9] '

Enchaîner plusieurs filtres

# Erreurs mais pas les erreurs de monitoring
tail -f /var/log/app.log \
  | grep --line-buffered 'ERROR' \
  | grep --line-buffered -v 'healthcheck'

`less +F` — l’alternative interactive

less +F démarre en mode suivi et vous laisse naviguer dans l’historique en cours de session :

less +F /var/log/syslog

Ctrl+C : arrête le suivi, permet de défiler avec les flèches
F : reprend le suivi temps réel
q : quitte

C’est utile quand vous voulez à la fois voir les nouvelles lignes ET remonter dans l’historique sans quitter.

`journalctl` — les journaux systemd

journalctl interroge le journal binaire de systemd. Contrairement aux fichiers plats, ce journal centralise les messages de tous les services — avec métadonnées, priorités et numérotation de boot.

Suivi en temps réel

journalctl -f                           # toutes les unités, en direct
journalctl -f -u nginx                  # service nginx seulement
journalctl -f -u nginx -u postgresql    # nginx ET postgresql
journalctl -f -p err                    # erreurs seulement, en direct

Filtrer par unité systemd

journalctl -u nginx --no-pager          # tout l'historique de nginx
journalctl -u nginx -n 50 --no-pager    # 50 dernières lignes
journalctl -u nginx -f                  # en direct

Filtrer par priorité

Les niveaux suivent la convention syslog (du plus au moins critique) :

Niveau	Valeur	Signification
`emerg`	0	Système inutilisable
`alert`	1	Action immédiate requise
`crit`	2	Condition critique
`err`	3	Erreurs
`warning`	4	Avertissements
`notice`	5	Conditions normales notables
`info`	6	Messages informatifs
`debug`	7	Messages de debug

-p err filtre les niveaux err et plus critiques (0 à 3) :

journalctl -p err --since "1 hour ago" --no-pager
journalctl -p warning --since today --no-pager   # avertissements et plus critiques

Filtrer par plage horaire

journalctl --since "2026-04-09 10:00:00" --until "2026-04-09 11:00:00" --no-pager
journalctl --since today --no-pager
journalctl --since yesterday --no-pager
journalctl --since "1 hour ago" --no-pager

Filtrer par démarrage système

journalctl -b --no-pager           # boot actuel
journalctl -b -1 --no-pager        # boot précédent
journalctl --list-boots            # liste tous les démarrages connus

C’est utile après un crash : journalctl -b -1 -p err montre les erreurs du dernier boot.

Messages kernel

journalctl -k --no-pager           # messages kernel (équivalent dmesg)
journalctl -k --since "1 hour ago" --no-pager

Combiner journalctl et grep

# Chercher les connexions SSH échouées
journalctl -u sshd --since today --no-pager | grep 'Failed\|Invalid'

# Compter les erreurs par service sur la dernière heure
journalctl -p err --since "1 hour ago" --no-pager \
  | awk '{print $5}' | sort | uniq -c | sort -rn

Choisir entre tail -f et journalctl

Situation	Outil recommandé
Service avec logs dans `/var/log/*.log`	`tail -f`
Service systemd sans fichier de log dédié	`journalctl -f -u <service>`
Filtrer par priorité ou plage horaire	`journalctl`
Investigation post-crash (boot précédent)	`journalctl -b -1`
Suivre plusieurs fichiers non-systemd	`tail -f fichier1 fichier2`
Mode interactif avec navigation historique	`less +F`

Cas d’usage admin

# Surveiller un déploiement : voir les logs app + nginx simultanément
tail -f /var/log/app/production.log /var/log/nginx/error.log

# Alerter sur les erreurs pendant un déploiement
tail --follow=name --retry /var/log/app/production.log \
  | grep --line-buffered 'ERROR\|FATAL' \
  | while read -r line; do
      echo "[ALERTE] $line"
      # logger -t deploy_monitor "$line"  # optionnel : envoyer dans syslog
    done

# Diagnostiquer pourquoi un service n'a pas démarré
journalctl -u mon-service -b --no-pager | tail -n 30

# Voir toutes les erreurs depuis hier
journalctl -p err --since yesterday --no-pager | grep -v 'kernel'

# Top des services les plus bruyants en erreurs (dernière heure)
journalctl -p err --since "1 hour ago" --no-pager \
  | awk 'NR>1 {print $5}' | sort | uniq -c | sort -rn | head -10

À retenir

tail -f suit un fichier par descripteur ; --follow=name --retry survit à la rotation — utilisez le second en production.
grep --line-buffered est obligatoire dans un pipeline avec tail -f pour éviter le buffering silencieux.
journalctl -f -u <service> est l’équivalent systemd de tail -f — sans risque de rotation.
journalctl -b -1 -p err est le premier réflexe après un crash : erreurs du boot précédent.
less +F permet de naviguer dans l’historique sans quitter le mode suivi.

Prochaines étapes

Expressions régulières de base Écrire des patterns précis pour filtrer efficacement avec grep.

Logs avec journalctl Gérer la rétention, la persistance et l'export des journaux systemd.

Trier, compter et dédoublonner Analyser un log avec sort, uniq -c et le pipeline top-N.

Gestion des services avec systemctl Démarrer, arrêter, activer et diagnostiquer les services systemd.

Référence grep Toutes les options grep — dont --line-buffered, -E et -v indispensables dans un pipeline tail -f.