Rechercher du texte avec grep sous Linux

Introduction

Dans cet atelier, vous allez apprendre à rechercher efficacement du texte à l'intérieur de fichiers sur un système Linux en utilisant la puissante commande grep. Vous commencerez par effectuer des recherches simples de chaînes de caractères spécifiques dans un ou plusieurs fichiers, tout en comprenant comment grep affiche les lignes correspondantes et identifie le fichier source lors d'une recherche multi-emplacements.

En vous appuyant sur ces bases, vous explorerez des fonctionnalités plus avancées pour affiner vos recherches. Vous apprendrez à afficher les numéros de ligne pour mieux vous situer, à utiliser des ancres telles que ^ et $ pour faire correspondre des motifs au début ou à la fin d'une ligne, et à exploiter la puissance des expressions régulières (basiques et étendues) pour réaliser des filtrages complexes et flexibles.

Effectuer une recherche de base dans des fichiers avec grep

Dans cette étape, vous allez apprendre l'utilisation fondamentale de la commande grep pour effectuer des recherches simples dans des fichiers. La commande grep (Global Regular Expression Print) est un utilitaire de ligne de commande puissant utilisé pour rechercher une chaîne ou un motif spécifique dans un ou plusieurs fichiers et afficher les lignes qui le contiennent.

La syntaxe de base de grep est : grep PATTERN [FILE...]

Commençons par une tâche simple : trouver des informations sur notre utilisateur actuel, labex, dans la base de données des utilisateurs du système. Ces informations sont stockées dans le fichier /etc/passwd.

Exécutez la commande suivante dans votre terminal pour trouver toutes les lignes contenant la chaîne labex dans le fichier /etc/passwd :

grep labex /etc/passwd

Vous devriez voir une ligne de sortie provenant du fichier contenant votre nom d'utilisateur, labex.

labex:x:5000:5000::/home/labex:/usr/bin/zsh

La commande grep peut également effectuer des recherches dans plusieurs fichiers simultanément. Nous allons maintenant rechercher la chaîne labex dans trois fichiers de configuration système importants : /etc/passwd, /etc/shadow (qui stocke les informations sécurisées des comptes utilisateurs) et /etc/group (qui définit les groupes d'utilisateurs).

Comme le fichier /etc/shadow contient des informations sensibles, vous avez besoin de privilèges administratifs pour le lire. Vous pouvez utiliser la commande sudo pour exécuter grep avec ces privilèges. L'utilisateur labex est configuré avec un accès sudo sans mot de passe.

Exécutez la commande suivante pour rechercher labex dans les trois fichiers :

sudo grep labex /etc/passwd /etc/shadow /etc/group

Remarquez que lors d'une recherche dans plusieurs fichiers, grep fait précéder chaque ligne correspondante du nom du fichier où la correspondance a été trouvée.

/etc/passwd:labex:x:5000:5000::/home/labex:/usr/bin/zsh
/etc/shadow:labex:$y$j9T$L6UYJUCu2XytrdFToEOw.1$yp2xAOVTbIPmbABMnS/xDsyce7xayU80JgIs3lrqw4B:20265:0:99999:7:::
/etc/group:sudo:x:27:labex
/etc/group:ssl-cert:x:121:labex
/etc/group:labex:x:5000:
/etc/group:public:x:5002:labex

Cela vous montre toutes les lignes de ces trois fichiers qui sont liées à l'utilisateur labex.

Afficher les numéros de ligne avec l'option -n

Dans cette étape, vous apprendrez à améliorer la sortie de grep en affichant les numéros de ligne où les correspondances sont trouvées. C'est particulièrement utile lorsque vous devez localiser un motif dans un fichier volumineux pour une édition ou une analyse ultérieure. L'option -n indique à grep de faire précéder chaque ligne de sortie de son numéro de ligne correspondant dans le fichier source.

Reprenons la commande de l'étape précédente. Vous avez recherché l'utilisateur labex dans trois fichiers système. Maintenant, vous allez effectuer la même recherche mais en affichant également les numéros de ligne pour chaque correspondance.

Ajoutez l'option -n à la commande que vous avez exécutée précédemment. N'oubliez pas d'utiliser sudo car vous accédez toujours au fichier restreint /etc/shadow.

Exécutez la commande suivante dans votre terminal :

sudo grep -n labex /etc/passwd /etc/shadow /etc/group

Vous verrez une sortie similaire à la précédente, mais chaque ligne est désormais précédée du nom du fichier et du numéro de ligne où la correspondance a eu lieu, séparés par des deux-points.

/etc/passwd:32:labex:x:5000:5000::/home/labex:/usr/bin/zsh
/etc/shadow:32:labex:$y$j9T$L6UYJUCu2XytrdFToEOw.1$yp2xAOVTbIPmbABMnS/xDsyce7xayU80JgIs3lrqw4B:20265:0:99999:7:::
/etc/group:21:sudo:x:27:labex
/etc/group:60:ssl-cert:x:121:labex
/etc/group:61:labex:x:5000:
/etc/group:62:public:x:5002:labex

Notez les numéros tels que 32, 32, 21, 60, 61 et 62 dans la sortie. Ce sont les numéros de ligne. Par exemple, la chaîne labex a été trouvée à la ligne 32 de /etc/passwd et à la ligne 32 de /etc/shadow. Cette option simple fait de grep un outil encore plus efficace pour naviguer et comprendre le contenu des fichiers.

Cibler la position dans la ligne avec les ancres ^ et $

Dans cette étape, vous allez perfectionner vos compétences avec grep en apprenant à utiliser les ancres. Les ancres sont des caractères spéciaux dans les expressions régulières qui ne correspondent pas à des caractères réels, mais plutôt à des positions dans une ligne. Cela vous permet de créer des motifs de recherche plus précis et plus puissants. Les deux ancres les plus courantes sont :

• ^ (accent circonflexe) : Correspond au début d'une ligne.
• $ (signe dollar) : Correspond à la fin d'une ligne.

Voyons comment elles fonctionnent en utilisant le fichier /etc/passwd.

Considérons d'abord une recherche simple de la chaîne root dans /etc/passwd :

grep root /etc/passwd

Vous pourriez obtenir plusieurs lignes en sortie, car d'autres entrées pourraient contenir la chaîne "root".

root:x:0:0:root:/root:/bin/bash
operator:x:11:0:operator:/root:/sbin/nologin

Maintenant, affinons cela. Dans le fichier /etc/passwd, le premier champ de chaque enregistrement est le nom d'utilisateur. Pour trouver spécifiquement l'enregistrement de l'utilisateur root, vous pouvez ancrer votre recherche au début de la ligne en utilisant ^.

Exécutez la commande suivante. Le motif ^root indique à grep de ne faire correspondre que les lignes qui commencent par root.

grep ^root /etc/passwd

Cette fois, la sortie est beaucoup plus précise, n'affichant que la ligne de l'utilisateur root.

root:x:0:0:root:/root:/bin/bash

Ensuite, utilisons l'ancre de fin de ligne, $. Le dernier champ d'un enregistrement /etc/passwd spécifie le shell de connexion par défaut de l'utilisateur. Nous pouvons l'utiliser pour trouver tous les utilisateurs qui ont /bin/bash comme shell par défaut.

Le motif bash$ correspondra à toute ligne qui se termine par la chaîne bash.

grep bash$ /etc/passwd

Cette commande affichera toutes les entrées d'utilisateurs où /bin/bash est le shell assigné.

root:x:0:0:root:/root:/bin/bash

(Note : Votre sortie peut varier si d'autres utilisateurs sur le système utilisent également bash comme shell par défaut.)

En utilisant les ancres ^ et $, vous pouvez réduire considérablement vos résultats de recherche pour trouver exactement ce que vous cherchez.

Faire correspondre des motifs avec les expressions régulières basiques

Dans cette étape, vous explorerez comment utiliser les expressions régulières basiques (BRE) avec grep pour créer des motifs de recherche plus flexibles. Dans les BRE, certains caractères, appelés métacaractères, ont des significations spéciales qui vont au-delà de leur valeur littérale. Cela vous permet de rechercher des motifs, et pas seulement des chaînes de caractères fixes.

Nous allons explorer deux métacaractères fondamentaux : * (astérisque) et . (point).

Examinons d'abord l'astérisque (*). Ce métacaractère correspond au caractère qui le précède immédiatement, présent zéro, une ou plusieurs fois. Pour voir cela en action, exécutez la commande suivante. Nous entourerons le motif de guillemets simples ('roo*') pour nous assurer que le shell le traite comme un motif littéral et n'essaie pas d'interpréter * comme un joker de fichier.

grep 'roo*' /etc/passwd

La sortie affichera probablement plusieurs lignes :

root:x:0:0:root:/root:/bin/bash
proxy:x:13:13:proxy:/bin:/usr/sbin/nologin
systemd-timesync:x:104:110:systemd Time Synchronization,,,:/run/systemd:/usr/sbin/nologin
rtkit:x:108:113:RealtimeKit,,,:/proc:/usr/sbin/nologin
operator:x:11:0:operator:/root:/sbin/nologin

Analysons ce résultat. Le motif 'roo*' recherche les lignes contenant ro suivi de zéro ou plusieurs o.

• La ligne root correspond car elle contient roo (ro suivi d'un o).
• La ligne proxy correspond car elle contient ro (ro suivi de zéro o) dans "proxy".
• La ligne systemd-timesync correspond car elle contient ro dans "Synchronization".
• La ligne rtkit correspond car elle contient ro dans "proc".
• La ligne operator correspond car elle contient ro à la fois dans "operator" et "/root".

Regardons maintenant le métacaractère point (.). Le point correspond à n'importe quel caractère unique. Exécutez la commande suivante pour voir comment son comportement diffère :

grep 'ro.' /etc/passwd

Cette fois, la sortie montre plusieurs correspondances :

root:x:0:0:root:/root:/bin/bash
proxy:x:13:13:proxy:/bin:/usr/sbin/nologin
systemd-timesync:x:104:110:systemd Time Synchronization,,,:/run/systemd:/usr/sbin/nologin
rtkit:x:108:113:RealtimeKit,,,:/proc:/usr/sbin/nologin
operator:x:11:0:operator:/root:/sbin/nologin

Le motif 'ro.' recherche les lignes contenant ro suivi d'exactement un caractère, quel qu'il soit.

• La ligne root correspond car ro est suivi de o dans "root".
• La ligne proxy correspond car ro est suivi de x dans "proxy".
• La ligne systemd-timesync correspond car ro est suivi de n dans "Synchronization".
• La ligne rtkit correspond car ro est suivi de c dans "proc".
• La ligne operator correspond car ro est suivi d'un autre caractère dans "operator" et "/root".

En comparant les sorties, vous pouvez clairement voir la puissance des expressions régulières. Les deux motifs 'roo*' et 'ro.' correspondent à plusieurs lignes, démontrant comment différents métacaractères vous permettent d'affiner vos recherches de différentes manières.

Utiliser les expressions régulières étendues pour des recherches complexes

Dans cette étape, vous apprendrez à utiliser les expressions régulières étendues (ERE) pour effectuer des recherches encore plus complexes et puissantes. Les ERE offrent un ensemble de métacaractères plus riche que les expressions régulières basiques (BRE). Pour activer les ERE, vous pouvez utiliser la commande grep -E ou son alias traditionnel, egrep. L'utilisation de grep -E est l'approche la plus moderne et recommandée.

Explorons d'abord les quantificateurs. Dans les ERE, vous pouvez spécifier le nombre exact de fois qu'un caractère doit apparaître en utilisant des accolades {}. Par exemple, pour trouver toute ligne contenant exactement deux 'o' minuscules consécutifs, vous pouvez utiliser le motif o{2}.

Exécutez la commande suivante. Nous entourons le motif de guillemets simples pour empêcher le shell de mal interpréter les caractères spéciaux.

grep -E 'o{2}' /etc/passwd

La sortie affichera plusieurs lignes contenant "oo" :

root:x:0:0:root:/root:/bin/bash
lp:x:7:7:lp:/var/spool/lpd:/usr/sbin/nologin
news:x:9:9:news:/var/spool/news:/usr/sbin/nologin
uucp:x:10:10:uucp:/var/spool/uucp:/usr/sbin/nologin
operator:x:11:0:operator:/root:/sbin/nologin

Cette commande fonctionne car le motif o{2} cible spécifiquement deux caractères 'o' consécutifs, présents dans "root", "spool" et d'autres entrées.

Ensuite, examinons l'alternance. Cette fonctionnalité puissante des ERE vous permet de rechercher l'un des plusieurs motifs possibles en utilisant le symbole tube |, qui agit comme un opérateur 'OU'.

Par exemple, si vous vouliez trouver un enregistrement d'utilisateur pour root ou Root (au cas où vous ne seriez pas sûr de la casse), vous pourriez utiliser la commande suivante :

grep -E 'root|Root' /etc/passwd

Cette commande recherche toute ligne contenant soit la chaîne root, soit la chaîne Root. La sortie affiche :

root:x:0:0:root:/root:/bin/bash
operator:x:11:0:operator:/root:/sbin/nologin

La ligne de l'utilisateur root et la ligne operator correspondent toutes deux car elles contiennent la chaîne "root" en minuscules.

Les expressions régulières étendues, activées avec grep -E, offrent une syntaxe plus expressive et puissante pour élaborer des motifs de recherche complexes, faisant de grep un outil indispensable pour le traitement de texte.

Résumé

Dans cet atelier, vous avez appris à utiliser la commande grep pour effectuer des recherches de texte fondamentales sous Linux. Vous avez commencé par exécuter des recherches de base pour une chaîne spécifique dans un seul fichier, puis vous avez étendu cela à plusieurs fichiers, en observant comment grep préfixe les lignes correspondantes avec leurs noms de fichiers respectifs. Vous avez également appris à utiliser l'option -n pour afficher le numéro de ligne de chaque correspondance, ce qui est utile pour localiser des motifs dans les fichiers.

De plus, vous avez exploré des capacités de correspondance de motifs plus avancées en utilisant des ancres pour trouver du texte au début (^) ou à la fin ($) d'une ligne. L'atelier a progressé pour couvrir l'utilisation des expressions régulières basiques et étendues, vous permettant de construire des motifs de recherche plus complexes et puissants pour extraire des informations spécifiques au sein des fichiers.