Comprendre grep vite: options utiles et cas concrets

Comprendre grep vite : options utiles et cas concrets

grep fait partie des commandes Linux les plus rentables à apprendre. En quelques options bien choisies, vous pouvez retrouver une erreur dans un log, vérifier une configuration, filtrer une liste de résultats ou repérer une chaîne précise dans un arbre de fichiers. Pour un usage terrain, l’objectif n’est pas de mémoriser toute la documentation, mais de connaître les options qui font gagner du temps immédiatement.

Dans ce tutoriel, vous allez voir comment utiliser grep rapidement avec des cas concrets sur des logs, des fichiers de configuration et des recherches ciblées. Les exemples sont pensés pour fonctionner dans un shell Linux classique, avec la version GNU de grep présente sur la majorité des distributions.

À quoi sert grep en pratique

La commande grep recherche des motifs textuels dans un fichier ou dans une sortie de commande. Son nom vient historiquement de l’éditeur ed, mais en pratique, retenez surtout ceci : grep sert à trouver vite une information utile dans beaucoup de texte.

Cas d’usage fréquents :

chercher une erreur dans /var/log/syslog, /var/log/auth.log ou les journaux d’une application ;
vérifier si une option est présente dans un fichier comme /etc/ssh/sshd_config ou /etc/fstab ;
filtrer une sortie longue, par exemple celle de ps, ip, ss ou journalctl ;
rechercher un mot-clé dans tout un projet avec récursivité ;
compter des occurrences ou exclure les lignes non pertinentes.

La syntaxe minimale à connaître

La forme la plus simple est :

grep "motif" fichier

Exemple :

grep "PermitRootLogin" /etc/ssh/sshd_config

Cette commande affiche les lignes contenant exactement la chaîne PermitRootLogin.

Vous pouvez aussi filtrer la sortie d’une autre commande avec un pipe :

ps aux | grep ssh

Ou rechercher dans plusieurs fichiers :

grep "error" *.log

Les options grep les plus utiles à apprendre en premier

-i : ignorer la casse

Par défaut, grep distingue les majuscules et les minuscules. Avec -i, il les ignore.

grep -i "error" /var/log/syslog

Utile quand un mot peut apparaître sous plusieurs formes : Error, ERROR, error.

-n : afficher le numéro de ligne

Très pratique pour corriger un fichier de configuration ou retrouver un passage précis.

grep -n "Listen" /etc/apache2/ports.conf

Le résultat affiche la ligne concernée, ce qui évite d’ouvrir le fichier au hasard.

-r ou -R : rechercher récursivement

Pour chercher dans un dossier et ses sous-dossiers :

grep -r "server_name" /etc/nginx/

Sur le terrain, c’est une option essentielle pour retrouver une directive dans une arborescence de configuration ou un dépôt de scripts.

-r suit la structure des répertoires. -R gère aussi les liens symboliques de manière plus large selon l’implémentation GNU grep. Si vous ne voulez pas de surprise, utilisez -r dans les cas courants.

-l : afficher seulement les noms de fichiers

Si vous voulez savoir dans quels fichiers un motif apparaît, sans afficher les lignes :

grep -rl "ProxyPass" /etc/apache2/

Très utile avant une modification en masse.

-v : inverser la recherche

Cette option affiche les lignes qui ne correspondent pas au motif.

grep -v "^#" /etc/fstab

Ici, on exclut les lignes commentées commençant par #.

-w : chercher un mot entier

Pour éviter les faux positifs :

grep -w "root" /etc/passwd

Sans -w, grep peut aussi trouver une chaîne incluse dans un mot plus long.

-c : compter les correspondances

Pour obtenir un total rapidement :

grep -c "Failed password" /var/log/auth.log

Utile pour une première estimation avant une analyse plus détaillée.

-A, -B, -C : afficher le contexte

Quand une ligne seule ne suffit pas, vous pouvez demander des lignes avant ou après.

-A 3 : 3 lignes après
-B 3 : 3 lignes avant
-C 3 : 3 lignes avant et après

grep -C 2 "error" application.log

Dans un log, cette option aide à comprendre la séquence d’événements autour d’une erreur.

-E : utiliser des expressions régulières étendues

Avec -E, vous pouvez écrire des motifs plus pratiques sans trop échapper les caractères.

grep -E "error|warning|critical" application.log

Cette commande trouve plusieurs mots-clés en une seule passe.

--color=auto : surligner les résultats

Sur beaucoup de systèmes, la couleur est déjà activée par défaut via un alias. Sinon :

grep --color=auto "sshd" /var/log/auth.log

Le motif recherché est mis en évidence, ce qui améliore fortement la lecture.

Premier réflexe utile : nettoyer un fichier de configuration

Quand vous ouvrez un fichier de configuration Linux, il contient souvent des commentaires et des lignes vides. Avant de chercher une directive, il peut être utile de ne garder que le contenu actif.

Exemple avec /etc/ssh/sshd_config :

grep -v "^#" /etc/ssh/sshd_config | grep -v "^$"

Cette commande retire d’abord les commentaires, puis les lignes vides.

Vous pouvez aussi faire la même chose avec une expression régulière étendue :

grep -Ev "^#|^$" /etc/ssh/sshd_config

Résultat : le fichier devient beaucoup plus lisible pour une vérification rapide.

Cas concret : vérifier une option SSH

Pour savoir si l’authentification par mot de passe est activée :

grep -En "^[[:space:]]*PasswordAuthentication" /etc/ssh/sshd_config

Ce motif tolère les espaces au début de ligne et cible la directive elle-même. C’est utile car certains fichiers de configuration sont indentés.

Analyser des logs système avec grep

Les logs sont l’un des meilleurs terrains d’apprentissage pour grep. Sur Debian et Ubuntu, vous rencontrerez souvent /var/log/syslog et /var/log/auth.log. Sur d’autres systèmes, une partie des événements peut être consultée via journalctl.

Repérer des erreurs dans syslog

Recherche simple :

grep -i "error" /var/log/syslog

Approche plus large avec plusieurs niveaux de gravité courants :

grep -Ei "error|warning|critical|failed" /var/log/syslog

Ce type de filtre donne un premier tri rapide. Attention toutefois : tous les logiciels n’utilisent pas les mêmes mots-clés, donc il faut souvent adapter la recherche au service concerné.

Surveiller les échecs de connexion SSH

Sur un serveur, l’un des cas les plus fréquents est l’analyse des tentatives de connexion échouées.

grep "Failed password" /var/log/auth.log

Pour compter le nombre de lignes correspondantes :

grep -c "Failed password" /var/log/auth.log

Pour extraire uniquement les adresses IP, on combine grep avec d’autres outils, par exemple awk ou sort, mais même avec grep seul, on peut déjà isoler les lignes utiles.

Exemple avec contexte si vous cherchez ce qui se passe autour d’un échec :

grep -C 2 "Failed password" /var/log/auth.log

Filtrer les logs de journalctl

Sur les systèmes utilisant systemd, journalctl produit souvent beaucoup de sortie. grep devient alors un filtre de précision.

journalctl -u ssh | grep -i "failed"

Ou pour un service web :

journalctl -u nginx | grep -Ei "error|warn"

Cette approche est utile quand vous connaissez déjà le service à inspecter.

Rechercher dans un projet ou un dossier de configuration

Un autre usage très rentable de grep consiste à chercher une chaîne dans plusieurs fichiers. C’est fréquent dans :

un répertoire /etc ;
des virtual hosts Apache ou Nginx ;
un dépôt Git ;
un ensemble de scripts shell.

Trouver une directive Nginx

grep -Rni "client_max_body_size" /etc/nginx/

Cette commande combine plusieurs options utiles :

-R : recherche récursive ;
-n : numéro de ligne ;
-i : casse ignorée.

En une seule commande, vous obtenez l’emplacement exact de la directive.

Trouver tous les fichiers qui mentionnent un domaine

grep -rl "example.com" /etc/apache2/

Très pratique lors d’une migration ou d’un audit de configuration.

Éviter certains fichiers ou dossiers

Quand on cherche dans un projet, on veut souvent ignorer des répertoires comme .git ou des fichiers de sauvegarde. GNU grep propose des options adaptées.

grep -Rni --exclude-dir=.git "TODO" .

Ou pour ignorer certains types de fichiers :

grep -Rni --exclude="*.min.js" "fetch(" .

Ces options sont très utiles dans un contexte de développement ou d’audit de scripts.

Bien utiliser grep avec les expressions régulières

Vous n’avez pas besoin de devenir expert en expressions régulières pour être efficace. Quelques motifs simples couvrent déjà beaucoup de besoins.

Début et fin de ligne

^ : début de ligne
$ : fin de ligne

Exemples :

grep "^root:" /etc/passwd

grep "nologin$" /etc/passwd

Lignes vides et commentaires

grep "^$" fichier.txt

Trouve les lignes vides.

grep "^#" fichier.conf

Trouve les lignes commentées.

Plusieurs mots-clés avec -E

grep -E "sshd|sudo|su" /var/log/auth.log

Pratique pour faire un premier balayage d’un log d’authentification.

Classes de caractères POSIX

GNU grep gère les classes POSIX, utiles pour rester portable dans beaucoup de contextes.

[[:space:]] : espaces, tabulations
[[:digit:]] : chiffres
[[:alpha:]] : lettres

Exemple :

grep -E "^[[:space:]]*Port[[:space:]]+22$" /etc/ssh/sshd_config

Cette commande cherche une ligne de configuration Port 22 en tolérant les espaces.

Cas concrets utiles au quotidien

1. Vérifier si un utilisateur existe dans /etc/passwd

grep "^alice:" /etc/passwd

Le début de ligne évite les faux positifs. Vous ciblez une entrée complète d’utilisateur.

2. Voir les montages actifs dans fstab hors commentaires

grep -Ev "^#|^$" /etc/fstab

Très utile avant une modification de disque, de partition ou de montage réseau.

3. Retrouver les lignes contenant une IP dans un log

Si vous cherchez une forme IPv4 simple :

grep -E "[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+" access.log

Ce motif est pratique pour un tri rapide, mais il ne valide pas strictement toutes les adresses IP. Pour un usage terrain, cela suffit souvent à repérer des lignes pertinentes.

4. Identifier les erreurs HTTP dans un log web

Dans un log d’accès Apache ou Nginx, vous pouvez rechercher certaines réponses HTTP.

grep -E "\" (404|500|502|503) " access.log

Le motif exact dépend du format de log utilisé, mais cette approche permet souvent de repérer rapidement les erreurs côté client ou serveur.

5. Chercher des variables dans des scripts shell

grep -Rni "PATH=" scripts/

Utile pour auditer des scripts ou retrouver où une variable d’environnement est définie.

6. Contrôler les ports déclarés dans des fichiers de configuration

grep -Rni "listen" /etc/nginx/

Ou pour Apache :

grep -Rni "Listen" /etc/apache2/

Pratique pour comprendre rapidement quels ports sont configurés sans lire tous les fichiers à la main.

Combiner grep avec d’autres commandes Linux

grep devient encore plus puissant quand il est combiné avec des commandes standard.

Avec ps

ps aux | grep nginx

Commande classique pour vérifier si un processus apparaît dans la liste.

Attention : cette sortie peut aussi afficher la commande grep nginx elle-même. Pour éviter cela, une astuce courante consiste à écrire :

ps aux | grep "[n]ginx"

Le motif correspond à nginx, mais la ligne contenant grep "[n]ginx" ne matche pas de la même manière.

Avec ip

ip addr | grep -n "inet "

Permet de repérer rapidement les lignes d’adresses IPv4 sur une machine.

Avec ss

ss -lntp | grep ":22 "

Utile pour vérifier qu’un service écoute bien sur le port SSH.

Avec dmesg

dmesg | grep -i "usb"

Pratique pour retrouver des événements liés à un périphérique.

Différence entre grep, egrep et fgrep

Sur les systèmes modernes, vous verrez parfois encore les noms egrep et fgrep. En pratique :

egrep correspond à grep -E ;
fgrep correspond à grep -F.

-F est utile si vous voulez chercher une chaîne littérale sans interprétation d’expression régulière.

grep -F "a.b" fichier.txt

Ici, le point est traité comme un caractère normal, pas comme un joker.

Sur un plan pratique, il vaut mieux retenir grep avec ses options plutôt que d’utiliser les anciennes commandes séparées.

Les erreurs fréquentes quand on débute avec grep

Oublier les guillemets autour du motif

Si le motif contient des espaces ou des caractères spéciaux, les guillemets évitent des comportements inattendus.

grep "Failed password" /var/log/auth.log

Chercher trop large

Une recherche sur error peut générer beaucoup de bruit. Ajoutez du contexte, ciblez un service ou combinez plusieurs mots-clés.

Confondre chaîne simple et expression régulière

Par défaut, certains caractères ont une signification spéciale. Si vous cherchez une chaîne littérale exacte, grep -F peut éviter des surprises.

Oublier les droits d’accès

Certains logs système ou fichiers de configuration nécessitent sudo.

sudo grep "Failed password" /var/log/auth.log

Utiliser grep là où l’outil source sait déjà filtrer

Parfois, il vaut mieux combiner intelligemment. Par exemple, journalctl sait déjà cibler une unité avec -u. grep intervient ensuite pour affiner, pas pour tout faire seul.

Méthode simple pour maîtriser grep rapidement

Si vous voulez devenir opérationnel vite, retenez cette progression :

étape 1 : apprendre grep "motif" fichier ;
étape 2 : ajouter -i, -n, -v, -r ;
étape 3 : utiliser -E pour plusieurs motifs ;
étape 4 : exploiter -A, -B, -C dans les logs ;
étape 5 : combiner grep avec ps, journalctl, ss, ip.

En quelques jours d’usage réel, ces options couvrent déjà une grande partie des besoins d’administration Linux et de diagnostic en ligne de commande.

Commandes grep à garder sous la main

grep -i "error" /var/log/syslog : chercher des erreurs sans tenir compte de la casse
grep -n "PermitRootLogin" /etc/ssh/sshd_config : trouver une directive avec son numéro de ligne
grep -Rni "server_name" /etc/nginx/ : chercher récursivement dans une configuration
grep -Ev "^#|^$" /etc/fstab : afficher seulement les lignes actives
grep -c "Failed password" /var/log/auth.log : compter des échecs SSH
grep -C 2 "error" application.log : afficher le contexte autour d’une erreur
ps aux | grep "[n]ginx" : vérifier un processus sans faire apparaître grep lui-même

Conclusion

grep est l’un des outils CLI les plus utiles pour aller droit au résultat sous Linux. En pratique, vous n’avez pas besoin d’en connaître toutes les subtilités pour être efficace : quelques options comme -i, -n, -r, -v, -E et -C suffisent déjà à résoudre beaucoup de problèmes concrets.

Pour progresser vite, entraînez-vous sur trois terrains simples : les logs, les fichiers de configuration et les sorties de commandes système. C’est là que grep devient vraiment rentable : moins de lecture inutile, des diagnostics plus rapides et des actions plus fiables.

Si vous utilisez grep tous les jours, le réflexe vient très vite. Et dans un environnement Linux orienté terrain, c’est précisément ce qu’on attend d’un bon outil : une commande simple, rapide et fiable.