Commande Grep PowerShell

La commande Grep (Global Regular Expression Print) est un outil de recherche de texte puissant dans les systèmes Unix/Linux. Grep prend un motif tel qu'une expression régulière ou une chaîne de caractères et recherche dans un ou plusieurs fichiers d'entrée les lignes qui contiennent le motif attendu. La commande Grep peut être utilisée de manière significative pour la recherche et le filtrage de texte, l'analyse de journaux, l'exploration de code, la gestion de configuration, l'extraction de données, etc. Dans le développement logiciel, la recherche de texte est utilisée pour la navigation dans le code, la refactorisation, le débogage, le diagnostic d'erreurs, l'analyse des menaces de sécurité, le contrôle de version et la revue de code. Les outils de recherche de texte peuvent réduire considérablement le temps des développeurs pour trouver des fonctions spécifiques, des variables ou des messages d'erreur. En administration système, la recherche de texte est pratique pour certaines tâches telles que l'analyse et la surveillance des journaux, la détection de sécurité et de menaces, le traitement des données et l'automatisation. Des outils de traitement de texte comme grep, awk et sed sont utilisés pour analyser les journaux afin d'examiner les événements d'authentification, les exceptions spécifiques et le filtrage des journaux par gravité, horodatage ou mots-clés aident les administrateurs à détecter les défaillances, les violations de sécurité et les problèmes de performance. Dans ce blog, nous explorerons de manière approfondie les fonctionnalités, les exemples et les cas d'utilisation de Grep. Select-String peut être utilisé comme équivalent de grep dans PowerShell pour windows, en utilisant la correspondance d'expressions régulières pour rechercher des motifs de texte dans les fichiers et les entrées.

Syntaxe et utilisation de base

La commande Grep est un outil puissant pour rechercher des motifs de texte pour le filtrage et l'analyse de texte dans Unix/Linux. Voici la structure de commande de base, contenant le motif, le fichier et les options.

grep [options] pattern [file…]

• Modèle : texte de l'expression régulière pour rechercher.
• Fichier : fichier ou fichiers dans lesquels effectuer la recherche.
• Options : Modificateurs ou commutateurs qui modifient le comportement de grep. Les options sont généralement précédées d'un trait d'union (-).

Voici certaines des options les plus fréquemment utilisées.

• -i: ignore la casse dans le motif de recherche et les données. Par exemple, la commande ci-dessous recherchera “hello”, “HELLO”, “Hello”, etc.

grep -i “hello” file.txt

• -v : Inverse la correspondance de recherche, affichant les lignes qui ne correspondent pas au motif. Par exemple, la commande ci-dessous affichera les lignes qui ne contiennent pas « hello », cette option est utile pour trouver les lignes qui ne correspondent pas aux critères spécifiques.

grep -v “hello” file.txt

• -n : Affiche le numéro de ligne avant chaque ligne correspondant aux critères et aide au partage de rapports. Par exemple, la commande ci-dessous montrera les numéros de ligne où le mot « fonction » apparaît.

grep -n “function” file.txt

• -r: Recherchez récursivement dans les répertoires, c'est-à-dire cherchez le motif dans tous les fichiers d'un répertoire et de ses sous-répertoires.
• –color: Met en évidence la chaîne correspondante dans le résultat. Par exemple, la commande ci-dessous mettra en surbrillance « hello » dans le résultat.

grep –color “hello” file.txt

• -l: liste uniquement les noms de fichiers dans lesquels il y a au moins une correspondance.

grep -l “starting” *.log

Compatibilité de la plateforme

Grep est intégré par défaut dans la ligne de commande des systèmes Unix/Linux et fonctionne de manière cohérente comme prévu. Il fonctionne avec des expressions régulières, prend en charge le piping et s'intègre de manière transparente avec d'autres outils Unix/Linux. Grep est disponible sur les systèmes Windows via le sous-système Windows pour Linux (WSL), qui permet aux utilisateurs d'exécuter des environnements GNU/Linux directement sur Windows, sans le surcoût d'une machine virtuelle. Plusieurs ports natifs de grep sont disponibles pour Windows, ce sont des versions autonomes compilées pour fonctionner directement sur Windows telles que Git Bash, Gnuwin32.

Bien que grep soit conçu pour être cohérent sur différentes plateformes, il existe certaines différences et limitations à prendre en compte lors de son utilisation sur diverses plateformes.

• Fins de ligne : Les systèmes Unix/Linux utilisent ‘\n’ pour les fins de ligne, tandis que Windows utilise ‘\r\n’.
• Spécification du chemin : Le comportement du système de fichiers diffère entre Unix/Linux et Windows, les chemins Windows utilisent des antislashs ‘\’ au lieu des ‘/’ utilisés dans Unix/Linux.
• Encodage des caractères : Les différentes plateformes utilisent des encodages de caractères par défaut variés, en particulier lorsqu'il s'agit de texte non-ASCII.
• Options en ligne de commande : La plupart des options courantes de grep sont prises en charge sur toutes les plateformes, il peut y avoir un support limité de grep sur différentes plateformes, tel qu'un support limité de la redirection sur window.

Exemples pratiques de grep en action

Recherches de texte simples

Dans l'exemple suivant, nous recherchons la chaîne de caractères « déploiement » dans un fichier journal

Grep “déploiement” logemail.log

Dans l'exemple suivant, nous recherchons une chaîne commençant par l'option -i qui ignorera la différence de cas.

grep -i “starting” logemail.log

Alors que si nous n'utilisons pas l'option -i, la chaîne exacte sera recherchée dans le fichier, c'est-à-dire grep “Starting” logemail.log la commande recherchera Starting et ignorera les correspondances telles que “starting” ou “STARTING” ou toute autre combinaison sensible à la casse de la chaîne “starting”.

Recherches récursives

Parfois, nous avons des fichiers dispersés dans différents répertoires et nous devons effectuer une recherche de motifs à travers plusieurs fichiers et répertoires. La commande grep avec une recherche récursive utilisant l'option -r ainsi que les options –include et –exclude offre une solution rapide. Dans la commande suivante, nous recherchons de manière récursive le motif « starting » dans tous les fichiers .log du répertoire courant et de ses sous-répertoires, et nous imprimons uniquement la première occurrence trouvée dans les fichiers journaux où le motif est détecté. Nous sommes actuellement dans le répertoire « Documents » qui contient des sous-répertoires, « office » et « project ».

grep -r “starting” –include=”*.log” -m1 –color=always

Dans l'exemple suivant, nous excluons tous les fichiers journaux et recherchons de manière récursive la chaîne « starting » dans tous les fichiers du répertoire « Documents » et ses sous-répertoires.

Grep -r “starting” –exclude=”*.log”

Inverser les correspondances

Nous pouvons utiliser l'option -v pour inverser le résultat de la recherche, de cette manière nous pouvons chercher une chaîne de caractères et trouver toutes les lignes qui ne contiennent pas cette chaîne. Dans l'exemple suivant, nous recherchons la chaîne de caractères « starting » avec l'option -v pour trouver toutes les lignes qui ne contiennent pas « starting ».

Grep -v “starting” logmail.log

Numéros de ligne et sortie contextuelle :

Lors de la recherche de motifs dans des fichiers, il est utile d'avoir les numéros de ligne exacts contenant le motif de recherche et parfois il est préférable d'avoir le contexte autour des correspondances de recherche, comme si nous explorons un fichier journal pour une exception, il est mieux d'inclure dans les résultats de recherche quelques lignes avant et après la chaîne de recherche. Dans l'exemple suivant, nous utilisons l'option -n pour imprimer les numéros de ligne avec le motif correspondant.

Grep -n “starting” logemail.log

En utilisant l'option -A, nous pouvons imprimer des lignes après un résultat de correspondance, avec l'option -B nous pouvons imprimer quelques lignes avant le résultat de correspondance et en utilisant -C nous pouvons imprimer des lignes avant et après les résultats de recherche. Dans les exemples suivants, nous utilisons -A, -B et -C pour montrer les lignes avant et après les résultats de recherche.

grep -A 2 “starting” logemail.log

grep -B 2 “starting” logemail.log

Grep -C 1 “starting” logemail.log

Utilisation des expressions régulières avec grep

L'expression régulière est une séquence de caractères qui définit un motif de recherche, elle est utilisée pour l'appariement et la manipulation de chaînes de caractères. Voici quelques-unes des expressions régulières de base.

• Point(.) : correspond à n'importe quel caractère unique sauf un saut de ligne, par exemple « c.t » correspond à cat, cot, crt, cet, etc.
• Astérisque (*): correspond à zéro ou plusieurs occurrences du caractère précédent, c'est-à-dire “c*t” correspond à ct, cat, caat, caaat, etc.
• Circonflexe (^) : Correspond au début de la ligne, par exemple ^an correspond à an si c'est au début de la ligne.
• Symbole du dollar ($) : Correspond à la fin de la ligne, c'est-à-dire que $finished correspond à finished si c'est à la fin de la ligne.
• Pipe (|) : le signe pipe dans Regex sert de OU logique, c'est-à-dire que (apple | banana) correspond soit à apple soit à banana dans la ligne.
• Caractère d'échappement (\) : Échappe un caractère spécial, par exemple \. Correspond à un point littéral.

Grep prend en charge les expressions régulières ; il utilise l'expression régulière de base (BRE) et prend également en charge l'expression régulière étendue (ERE) avec le drapeau -E et les expressions régulières compatibles Perl (PCERE) avec le drapeau -P. Les expressions régulières étendues offrent des métacaractères supplémentaires comme + (une ou plusieurs correspondances), ? (zéro ou une correspondance), | (OU logique), {} (groupement de motifs) pour des recherches de motifs plus avancées. Les expressions régulières compatibles Perl sont les plus puissantes et flexibles, offrant plus d'options comme les anticipations (?=), les rétrospections (?<!), les groupes non capturants (?:motif) et plus encore.

Dans l'exemple suivant, nous recherchons un mot entier dans un fichier et une variation de la commande grep avec correspondance de chaîne.

• Grep “end” log.txt, correspondra à toutes les variations possibles du mot end
• grep -w “end” log.txt, correspondra uniquement au mot entier « end »
• grep “\bend\b” log.txt, correspondra uniquement au mot entier « end » en utilisant les expressions régulières.
• Grep “\bend” log.txt, correspondra à la chaîne “end” en début de ligne.

Dans les exemples suivants, nous recherchons des chiffres dans un fichier « log.txt » avec différentes variations.

• grep “[0-9]” log.txt, trouvera toutes les lignes contenant un chiffre.
• grep “[0-9]\{3\}-[0-9]\{3\}-[0-9]\{4\}” log.txt , permettra de trouver un numéro de téléphone dans le fichier donné.
• grep -E “[0-9]{2,4}” log.txt , permettra de trouver les lignes contenant 2, 3 ou 4 chiffres consécutifs.

Dans l'exemple suivant, nous recherchons des espaces blancs dans un fichier log.txt

• grep “^[[:space:]]” log.txt permettra de trouver un espace au début d'une ligne.
• grep “^[[:space:]]” log.txt permettra de trouver un espace à la fin d'une ligne.

Avec la commande grep, nous pouvons trouver des motifs complexes tels que des adresses IP et des e-mails. Dans l'exemple suivant, nous utilisons une expression régulière pour trouver une adresse IP.

grep -E “\(?[0-9]{3}\)?[-. ]?[0-9]{3}[-. ]?[0-9]{4}” log.txt

Dans l'exemple suivant, nous utilisons une expression régulière pour trouver une adresse e-mail.

grep -E “[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}” log.txt

Techniques avancées d'expressions régulières (par exemple, lookahead et lookbehind avec -P)

Les techniques de lookahead et de lookbehind sont puissantes pour trouver des motifs basés sur les motifs qui les entourent. Par exemple, si nous voulons rechercher « erreur » dans un fichier journal mais seulement lorsqu'il y a également le démarrage d'une application dans la ligne. Il existe deux types de lookahead, le Positive lookahead et le Negative lookahead.

• L'assertion positive lookahead (?=…) garantit que le motif à l'intérieur des parenthèses suit la position actuelle mais ne l'inclut pas dans la correspondance, c'est-à-dire que nous pourrions rechercher le mot « error » s'il est immédiatement suivi par le mot « starting » dans les lignes de journal.
• La négation en avance ((?!…) garantit que le motif à l'intérieur des parenthèses ne suit pas la position actuelle, c'est-à-dire que nous pouvons rechercher le motif « starting » mais pas suivi du motif « error ».

grep -P “error(?= starting)” log.txt

grep -P “starting(?!= error)” log.txt

Il existe deux types de lookbehind, le lookbehind positif et le lookbehind négatif.

• Le positive lookbehind ( ?<=…) assure que le motif à l'intérieur des parenthèses précède la position actuelle, mais n'est pas inclus dans la correspondance.
• La négation en arrière-plan (?<!…) garantit que le motif à l'intérieur des parenthèses ne précède pas la position actuelle.

Grep -P “(?<=starting )error” log.txt

grep -P “error)?=.*starting)” log.txt

Fonctionnalités avancées de grep

Combiner plusieurs modèles

La commande Grep nous permet également de combiner plusieurs motifs de recherche, l'option -e peut être utilisée pour combiner plusieurs motifs. Dans l'exemple suivant, nous recherchons deux motifs différents dans un seul fichier.

Grep -e “starting” -e “error” log.txt

De plus, nous pouvons utiliser -e pour trouver plusieurs motifs dans plusieurs fichiers, c'est-à-dire « starting » dans le fichier log.txt et « error » dans logemail.log.

grep -e “starting” -e “error” log.txt logemail.log

Personnalisation de la sortie

Nous pouvons utiliser l'option –color pour mettre en évidence le motif recherché dans la sortie, que ce soit lors de l'affichage sur la console ou de la redirection vers un fichier.

• –color=auto décide d'utiliser la couleur ou non selon que la sortie est destinée au terminal
• –color=always, utilisez toujours la couleur, même si la sortie est redirigée vers un fichier.
• –color=never, n'utilisez jamais de couleur.

grep –color=auto “error” log.txt

grep –color=always “error” log.txt

grep –color=never “error” log.txt

Nous pouvons utiliser l'option -q pour modifier la sortie de la commande grep, afin de l'exécuter en mode silencieux. Utiliser l'option -q n'imprimera pas toutes les lignes correspondantes, juste le message personnalisé. Dans les exemples suivants, nous recherchons le motif « error » dans le fichier log.txt et imprimons « error found ».

grep -q “error” log.txt && echo “error found!” || echo “No error found”

if grep -qi “error” log.txt; then echo ” error found”; fi

Optimisation des performances

grep lit de grands fichiers sans les charger entièrement en mémoire, cependant nous pouvons améliorer ses performances avec quelques techniques supplémentaires.

• Abus de l'expression régulière : L'utilisation de Regex est coûteuse en termes de calcul, dans les cas où nous recherchons une chaîne littérale, nous pouvons utiliser grep avec une chaîne fixe pour éviter la surcharge de calcul de Regex.
• Utilisation de –mmap : –mmap peut être utilisé pour activer l'accès aux fichiers mappés en mémoire, si nous effectuons beaucoup d'accès aléatoires dans le fichier.
• Traitement parallèle : Si notre tâche nous permet de diviser le grand fichier et d'exécuter plusieurs processus grep sur différentes parties, cela peut être utile pour l'optimisation des performances car cela exécutera plusieurs instances du processus grep, et nous pourrons combiner les résultats par la suite.
• Limitation de la sortie : nous pouvons limiter la sortie pour afficher uniquement la première ou la deuxième occurrence de la recherche ou nous pouvons supprimer la sortie et vérifier uniquement l'existence du motif.

La commande Grep tamponne la sortie par défaut, ce qui peut retarder le traitement en temps réel lors de l'enchaînement des commandes dans les pipelines. L'option “--line-buffered” est utilisée pour forcer la sortie immédiate pour chaque correspondance. Dans l'exemple suivant, nous enchaînons tail avec grep pour surveiller en continu un fichier journal et afficher le motif “error” ligne par ligne.

Tail -f log.txt | grep –line-buffered “error”

Correspondance de motifs basée sur les fichiers

Nous pouvons créer un fichier de motifs à rechercher en utilisant la commande grep puis utiliser –file pour chercher ces multiples motifs à partir d'un fichier. Dans l'exemple suivant, nous avons créé un fichier pattern.txt contenant les motifs « starting », « application » et « INFO » et en utilisant –file dans la commande grep nous recherchons ces motifs dans le fichier logemail.log avec l'option -m2 pour afficher deux occurrences.

grep –file=pattern.txt -m2 logemai.log

Piping et Redirection avec grep

Nous pouvons utiliser la commande grep enchaînée avec d'autres commandes pour différents scénarios. Dans la commande suivante, nous utilisons la commande d'état des processus (ps) pour obtenir tous les processus et la transmettons avec grep pour n'afficher que les processus python.

ps aux | grep python

Dans l'exemple suivant, nous obtenons tous les fichiers et dossiers dans le répertoire actuel et filtrons uniquement les fichiers journaux avec la commande grep.

ls -a | grep ‘\.log$’

Dans l'exemple suivant, nous imprimons le nom des utilisateurs qui utilisent des processus python en utilisant les commandes ps, grep et awk.

ps aux | grep python | awk ‘{print $1}’

Dans l'exemple suivant, nous recherchons le motif « error » dans le fichier erros.txt et en utilisant la commande sed, nous mettons en évidence toutes les occurrences de « error » en tant que « Alert ».

grep “error” erros.txt | sed ‘s/error/ALERT/’

Dans les exemples suivants, nous recherchons un motif « error » dans le fichier log.txt et redirigeons la sortie vers un autre fichier erros.txt dans le répertoire courant. Dans la première commande, nous écrasons la sortie dans le fichier errors.txt et dans la seconde commande, nous ajoutons la sortie de grep dans le fichier error.txt.

grep “error” log.txt > errors.txt

grep “error” logemail.log >> errors.txt

Dans la commande suivante, nous utilisons tee pour écrire la sortie de grep dans le fichier erros.txt tout en l'affichant également sur la console.

grep “starting” logemail.log | tee errors.txt

Cas d'utilisation réels et exemples

Analyse et filtrage des fichiers journaux

(étant donné de nombreux exemples ci-dessus)

Traitement de texte et extraction à partir de fichiers de données

(étant donné de nombreux exemples ci-dessus)

Nous pouvons utiliser les commandes netstat et ss pour obtenir le statut des différents ports et quels processus écoutent sur ces ports en les combinant avec grep et en filtrant davantage spécifiquement sur certains ports. Dans les exemples suivants, nous utilisons les commandes netstat et ss pour obtenir tous les processus qui écoutent sur différents ports.

netstat -lntp | grep “LISTEN”

ss -lntp | grep “LISTEN”

Nous pouvons utiliser la commande grep avec d'autres commandes pour obtenir des informations système et rechercher rapidement différents paramètres. Dans les exemples suivants, nous vérifions différentes informations système qui sont pratiques à des fins de diagnostic.

ps aux | grep “CPU” # pour vérifier les statistiques du CPU.

df -h | grep “/dev/sd” # pour vérifier l'utilisation du disque.

ip a | grep “inet” # pour trouver les adresses ip

Personnalisation et création d'alias pour grep

Nous pouvons définir des alias pour la commande grep avec ses différentes options et utiliser ces alias au lieu de la commande grep avec options pour rechercher un motif.

alias g=’grep’

alias gi=’grep -i’

alias gr=’grep -r’

alias gc=’gr -n –color=auto’

Après avoir défini ces alias, nous pouvons utiliser les alias pour effectuer une recherche de motifs avec juste des alias.

g “error” -m1 log.txt

gi “error” -m1 log.txt

gr “error” -m1 log.txt

gc “error” -m1 log.txt

Nous pouvons écrire une fonction pour lire les 10 premiers journaux système. Dans l'exemple suivant, nous écrivons une fonction « find_error » pour lire le fichier syslog situé à l'emplacement « /var/log/systemlog » et afficher les 10 dernières lignes contenant le motif « error ».

find_errors{

grep -I “error” /var/log/syslog | tail -n 10

}

Trouver des erreurs

Nous utilisons les commandes tail, grep et tee pour rechercher dans syslog et filtrer les erreurs avec le mot-clé « error » tout en affichant le résultat sur la console et en l'ajoutant à un fichier journal.

tail -f /var/log/syslog | grep –line-buffered -i “error” | tee errors.txt

Intégration avec le Shell Scripting (Utilisation de grep avec des instructions conditionnelles et des boucles)

Exemples d'utilisation de grep dans des scripts shell pour l'automatisation

(Cette section est assez complexe et nécessite davantage de VM et de configuration Windows avec Linux, je n'ai pas eu le temps de partager des exemples, je conseillerais de changer le H2 en « Utilisation de grep avec des instructions conditionnelles et des boucles »)

Dans l'exemple suivant, nous utilisons grep -i pour rechercher un motif spécifique et redirigeons la sortie vers une boucle while qui traite ensuite chaque ligne correspondante.

#!/bin/bash

LOG_FILE=”/var/log/syslog”

PATTERN=”authentication”

grep -i “$PATTERN” “$LOG_FILE” | while read -r line; do

echo « Traitement de la ligne : $line »

# Effectuez un traitement supplémentaire ici

fait

Dans l'exemple suivant, nous utilisons des instructions conditionnelles avec les commandes ps et grep pour vérifier si un service est en cours d'exécution ou non.

#!/bin/bash

SERVICE=”CUPS”

if ! ps aux | grep -v grep | grep -q “$SERVICE”; then

echo ” $SERVICE n'est pas en cours d'exécution !”

autre

echo “$SERVICE est en cours d'exécution.”

fi

Dépannage et pièges courants

Surmonter les problèmes d'encodage

Les incompatibilités d'encodage peuvent entraîner l'échec de la commande grep lors de la recherche de motifs dans des caractères d'encodage différents. Nous pouvons définir la locale (LC_ALL=C) ou utiliser l'option –encoding pour corriger les problèmes d'encodage.

Gestion des caractères spéciaux et échappement

Les expressions régulières utilisent des caractères spéciaux qui doivent être échappés pour être utilisés au sens littéral. Le caractère d'échappement (\) est utilisé pour échapper ces caractères ou nous pouvons utiliser l'option -F (chaîne fixe) pour traiter les motifs comme des chaînes littérales.

Débogage de motifs regex complexes

Les expressions régulières complexes peuvent parfois être difficiles lorsqu'elles ne retournent pas de résultats conformément au scénario souhaité, les décomposer en petites parties et les tester une par une puis les combiner peut faire gagner du temps et identifier le problème.

Conclusion

Nous avons beaucoup parlé de la commande grep, de la fonctionnalité de base aux techniques avancées telles que les expressions régulières, les différentes options de la commande grep, le chaînage de grep avec d'autres commandes, la redirection de sortie, l'écriture de scripts et les techniques de dépannage. Comme toute autre technique de PowerShell, la pratique et l'expérimentation avec la commande grep amélioreront la compréhension et peuvent dévoiler des possibilités cachées de maîtriser l'automatisation du système.