Recueil de commandes PowerShell pratiques — enrichir les petits outils utilisés au quotidien

1. Ce qu’il faut retenir en premier

Une fois les bases de PowerShell acquises, l’étape suivante consiste à enrichir votre panoplie de « petits outils fréquemment utilisés » — c’est ce qui rend PowerShell réellement pratique au quotidien.

Par « petits outils », on ne parle pas d’alias courts. Dans cet article, plutôt que des abréviations comme ls ou cat, nous utilisons les noms de commandes complets tels que Get-ChildItem, Get-Content et Select-String.

Sur cette base, nous allons rendre possibles les tâches suivantes en une ligne ou quelques lignes de commande :

Compter des éléments
Vérifier la taille totale
Supprimer les doublons
Regrouper par catégorie
Extraire uniquement les valeurs nécessaires
Comparer deux résultats
Voir les lignes autour d'une correspondance dans un journal
Envoyer un résultat vers le presse-papiers
Enregistrer la sortie tout en l'affichant à l'écran
Vérifier les variables d'environnement et le réseau

PowerShell est utile même sans écrire de longs scripts. Commencez par enrichir votre ensemble de « briques fréquemment utilisées » afin de pouvoir les combiner progressivement dans votre travail quotidien.

Plutôt que de mémoriser des commandes, l’important est de pouvoir se rappeler : « dans cette situation, telle brique s’applique ».

Le code présenté dans cet article est publié sur GitHub sous la forme d’un ensemble d’exemples exécutables, organisé thème par thème selon la structure des chapitres (scripts de recettes et tests Pester).

powershell-practical-command-recipes - komurasoft-blog-samples (GitHub)

2. La démarche adoptée ici

Les trois principes de départ sont les suivants :

1. Écrire les commandes avec leur nom complet
2. Centrer le travail sur des commandes en lecture seule
3. Toujours associer les commandes de modification à une vérification de la cible et à -WhatIf

Par exemple, plutôt que d’apprendre directement la commande de suppression de fichiers, il est plus sûr d’intérioriser d’abord le déroulement suivant :

Regarder les cibles
  → filtrer selon une condition
  → les compter
  → les enregistrer en CSV si nécessaire
  → confirmer les modifications prévues
  → exécuter

Cet article se concentre sur l’investigation, l’agrégation, la comparaison et la sortie de données, plutôt que sur des opérations fortes comme la suppression ou l’arrêt.

3. Carte des commandes fréquemment utilisées

Voici les principales commandes utilisées cette fois-ci.

Il n’est pas nécessaire de tout mémoriser d’un coup. Nous recommandons de les retenir en les associant à un objectif : « pour compter, Measure-Object », « pour regrouper, Group-Object », « pour comparer, Compare-Object ».

4. Compter des éléments — Measure-Object

La première opération fréquente est le comptage.

Compter les fichiers du dossier courant.

Get-ChildItem . -File | Measure-Object

Pour inclure aussi les sous-dossiers :

Get-ChildItem . -File -Recurse | Measure-Object

Le Count du résultat de Measure-Object correspond au nombre d’éléments.

Pour voir la taille totale des fichiers, agrégez Length.

Get-ChildItem . -File -Recurse |
  Measure-Object -Property Length -Sum

Cependant, tel quel, le résultat est exprimé en octets et reste peu lisible pour un humain ; convertissez-le donc en Go.

$size = Get-ChildItem . -File -Recurse |
  Measure-Object -Property Length -Sum

[math]::Round($size.Sum / 1GB, 2)

C’est pratique lorsque vous voulez avoir un aperçu rapide de la taille totale d’un dossier.

5. Vérifier aussi le maximum et la moyenne

Measure-Object peut produire non seulement des sommes, mais aussi des maximums et des moyennes.

Get-ChildItem . -File |
  Measure-Object -Property Length -Sum -Average -Maximum -Minimum

C’est utile pour observer la dispersion des tailles de fichiers.

Vous pouvez également additionner le temps CPU cumulé des processus. La propriété CPU de Get-Process n’est pas un taux d’utilisation, mais le nombre de secondes de temps CPU consommées depuis le démarrage du processus.

Get-Process |
  Measure-Object -Property CPU -Sum

Notez toutefois que cette valeur est cumulative et non un taux d’utilisation CPU instantané ; elle varie donc selon le moment de l’exécution et la durée de fonctionnement des processus.

Elle est suffisante à des fins d’investigation, mais pour une surveillance rigoureuse, des outils de supervision dédiés et une conception des journaux sont également nécessaires.

6. Extraire uniquement les valeurs — Select-Object -ExpandProperty

Select-Object est couramment utilisé pour choisir des colonnes.

Get-Process |
  Select-Object Name, Id, CPU

Cela produit des « objets avec les colonnes Name, Id et CPU ».

En revanche, quand vous voulez uniquement les valeurs, utilisez -ExpandProperty.

Get-Process -Name notepad -ErrorAction SilentlyContinue |
  Select-Object -ExpandProperty Id

Il en va de même pour extraire uniquement les noms de fichiers.

Get-ChildItem . -File |
  Select-Object -ExpandProperty Name

Quand vous voulez transmettre le résultat d’une commande à une autre commande ou à un fichier texte, -ExpandProperty est pratique.

Par exemple, enregistrez uniquement la liste des noms de fichiers.

Get-ChildItem . -File |
  Select-Object -ExpandProperty Name |
  Set-Content .\file-names.txt -Encoding UTF8

Select-Object Name et Select-Object -ExpandProperty Name se ressemblent, mais la forme du résultat diffère.

Select-Object Name
  → un tableau avec une colonne Name

Select-Object -ExpandProperty Name
  → les valeurs de Name elles-mêmes

Si vous voulez une sortie CSV, conserver la colonne est préférable ; si vous voulez transmettre le résultat à un autre traitement de chaînes, les valeurs seules sont plus faciles à manipuler.

7. Supprimer les doublons — Sort-Object -Unique

Supposons que vous vouliez une liste des seules extensions de fichiers.

Get-ChildItem . -File |
  Select-Object -ExpandProperty Extension |
  Sort-Object -Unique

En l’exécutant, seules les extensions dédupliquées s’affichent, comme .txt, .log et .csv.

Vous pouvez également voir uniquement les noms de processus distincts.

Get-Process |
  Select-Object -ExpandProperty ProcessName |
  Sort-Object -Unique

Un exemple d’extraction de la seule liste des noms de départements à partir d’un CSV de liste d’utilisateurs :

Import-Csv .\users.csv |
  Select-Object -ExpandProperty Department |
  Sort-Object -Unique

Quand « la liste est encombrée de nombreuses valeurs identiques », penser d’abord à Sort-Object -Unique est pratique.

8. Regrouper par catégorie — Group-Object

Quand vous voulez non seulement dédupliquer, mais aussi savoir « combien il y en a de chaque », utilisez Group-Object.

Comptez les fichiers par extension.

Get-ChildItem . -File |
  Group-Object -Property Extension -NoElement |
  Sort-Object -Property Count -Descending

Ajouter -NoElement omet le contenu de chaque groupe, ce qui rend les décomptes plus faciles à lire.

Comptez par statut de service.

Get-Service |
  Group-Object -Property Status -NoElement

Comptez par niveau du journal des événements.

Get-WinEvent -LogName System -MaxEvents 500 |
  Group-Object -Property LevelDisplayName -NoElement

Group-Object convient bien pour saisir la vue d’ensemble au début d’une investigation.

Quelles extensions sont les plus courantes
Quels statuts de service sont les plus courants
Quels niveaux d'erreur sont les plus courants
Quel département a le plus de données

Utilisez-le quand vous voulez voir la distribution avant d’entrer dans le détail.

9. Créer les colonnes dont vous avez besoin — ajouter des colonnes calculées

La taille des fichiers est disponible via Length, mais l’unité est l’octet. Regarder des octets à chaque fois est pénible ; il est donc pratique de créer des colonnes converties en Mo ou en Ko.

Get-ChildItem . -File |
  Select-Object Name, @{Name="SizeKB"; Expression={ [math]::Round($_.Length / 1KB, 1) }}, LastWriteTime

Un exemple incluant les sous-dossiers et listant d’abord les plus gros fichiers :

Get-ChildItem . -File -Recurse |
  Sort-Object -Property Length -Descending |
  Select-Object -First 20 FullName, @{Name="SizeMB"; Expression={ [math]::Round($_.Length / 1MB, 2) }}, LastWriteTime

@{Name="..."; Expression={ ... }} est la syntaxe pour créer une colonne calculée. Cela paraît un peu long au premier abord, mais c’est utilisé constamment en pratique.

Par exemple, vous pouvez afficher l’utilisation mémoire des processus en Mo.

Get-Process |
  Sort-Object -Property WorkingSet -Descending |
  Select-Object -First 10 Name, Id, @{Name="MemoryMB"; Expression={ [math]::Round($_.WorkingSet / 1MB, 1) }}

Pour des rapports, une colonne comme SizeMB est bien plus lisible que le Length brut.

10. Voir les plus récents, les plus anciens et les plus gros en premier

Dans PowerShell, le tri se fait avec Sort-Object.

Voir les fichiers modifiés le plus récemment.

Get-ChildItem . -File |
  Sort-Object -Property LastWriteTime -Descending |
  Select-Object -First 10 Name, LastWriteTime

Voir les fichiers les plus anciens.

Get-ChildItem . -File |
  Sort-Object -Property LastWriteTime |
  Select-Object -First 10 Name, LastWriteTime

Voir les fichiers les plus gros.

Get-ChildItem . -File -Recurse |
  Sort-Object -Property Length -Descending |
  Select-Object -First 10 FullName, Length

Ces trois cas reviennent constamment.

Du plus récent → LastWriteTime -Descending
Du plus ancien → LastWriteTime
Du plus gros   → Length -Descending

Ce sont des combinaisons fréquentes dans l’investigation des journaux, le nettoyage des fichiers inutiles et l’investigation de l’espace disque.

11. N’utiliser les commandes Format qu’à la fin, pour l’affichage

Pour rendre les choses plus lisibles à l’écran, utilisez Format-Table et Format-List.

Get-Process |
  Sort-Object -Property WorkingSet -Descending |
  Select-Object -First 10 Name, Id, WorkingSet |
  Format-Table -AutoSize

Pour voir le détail d’un seul élément, Format-List est pratique.

Get-Process -Id $PID |
  Format-List *

Mais Format-Table et Format-List sont destinés à « l’affichage ».

Il est plus sûr de ne pas les utiliser avant une sortie CSV ou un traitement par les commandes suivantes.

# À éviter
Get-Process |
  Format-Table Name, Id |
  Export-Csv .\process.csv -NoTypeInformation

Pour une sortie CSV, choisissez les colonnes avec Select-Object.

# Correct
Get-Process |
  Select-Object Name, Id |
  Export-Csv .\process.csv -NoTypeInformation -Encoding UTF8

En cas de doute, raisonnez ainsi :

Uniquement pour regarder à l'écran → Format-Table / Format-List
Pour une utilisation ultérieure   → Select-Object

12. Rendre la recherche dans les journaux un peu plus pratique — Select-String

Pour rechercher des chaînes de caractères, utilisez Select-String.

Select-String -Path .\logs\*.log -Pattern "ERROR"

Plusieurs motifs peuvent être indiqués.

Select-String -Path .\logs\*.log -Pattern "ERROR", "WARN", "FATAL"

Pour voir les lignes voisines, utilisez -Context.

Select-String -Path .\logs\*.log -Pattern "ERROR" -Context 2

Cela affiche aussi les deux lignes avant et après chaque ligne correspondante, ce qui est utile pour comprendre le contexte d’une erreur.

Pour rechercher une chaîne littérale, utilisez -SimpleMatch.

Select-String -Path .\logs\*.log -Pattern "[ERROR]" -SimpleMatch

Le -Pattern de Select-String est normalement traité comme une expression régulière. Quand vous voulez rechercher littéralement des symboles comme [ ou ., ajouter -SimpleMatch évite toute ambiguïté.

Pour une recherche sensible à la casse :

Select-String -Path .\logs\*.log -Pattern "Error" -CaseSensitive

Les résultats de recherche peuvent aussi être conservés dans un CSV.

Select-String -Path .\logs\*.log -Pattern "ERROR" |
  Select-Object Path, LineNumber, Line |
  Export-Csv .\error-lines.csv -NoTypeInformation -Encoding UTF8

13. Remplacer des chaînes de caractères

Pour remplacer une partie d’une chaîne, utilisez -replace.

"server01.example.com" -replace "\.example\.com$", ""

Lors du remplacement du contenu d’un fichier, il est plus sûr de ne pas écraser directement le fichier d’origine. Sortez d’abord vers un fichier séparé.

(Get-Content .\appsettings.json -Raw) -replace "localhost", "db01" |
  Set-Content .\appsettings.preview.json -Encoding UTF8

Vérifiez, puis appliquez au fichier d’origine seulement si nécessaire.

Avec les fichiers de configuration et les remplacements en masse, un trop grand nombre de correspondances entraîne des incidents. Il est plus sûr de vérifier d’abord les cibles avec Select-String, puis de remplacer.

Select-String -Path .\appsettings.json -Pattern "localhost" -SimpleMatch

14. Comparer deux résultats — Compare-Object

Compare-Object est la commande pour voir les différences entre deux listes.

Par exemple, comparez des listes de noms de fichiers avant et après une modification.

Compare-Object `
  -ReferenceObject (Get-Content .\before.txt) `
  -DifferenceObject (Get-Content .\after.txt)

Voici la signification de SideIndicator.

Un exemple d’enregistrement et de comparaison des listes de noms de fichiers de dossiers :

Get-ChildItem .\before -File |
  Select-Object -ExpandProperty Name |
  Set-Content .\before-list.txt -Encoding UTF8

Get-ChildItem .\after -File |
  Select-Object -ExpandProperty Name |
  Set-Content .\after-list.txt -Encoding UTF8

Compare-Object `
  -ReferenceObject (Get-Content .\before-list.txt) `
  -DifferenceObject (Get-Content .\after-list.txt)

Vous pouvez aussi observer les changements dans la liste des services.

Get-Service |
  Select-Object Name, Status |
  Export-Csv .\services-before.csv -NoTypeInformation -Encoding UTF8

Après la modification, exportez à nouveau.

Get-Service |
  Select-Object Name, Status |
  Export-Csv .\services-after.csv -NoTypeInformation -Encoding UTF8

Comparez.

Compare-Object `
  -ReferenceObject (Import-Csv .\services-before.csv) `
  -DifferenceObject (Import-Csv .\services-after.csv) `
  -Property Name, Status

Conserver les écarts avant/après de votre travail facilite l’investigation et le reporting.

15. Vérifier les valeurs de hachage des fichiers — Get-FileHash

Quand vous voulez confirmer qu’un fichier téléchargé ou un fichier distribué est identique, utilisez les valeurs de hachage.

Get-FileHash .\installer.exe -Algorithm SHA256

Pour vérifier tous les fichiers d’un dossier en une fois :

Get-ChildItem .\downloads -File |
  ForEach-Object { Get-FileHash -LiteralPath $_.FullName -Algorithm SHA256 }

Cela peut aussi être conservé dans un CSV.

Get-ChildItem .\downloads -File |
  ForEach-Object { Get-FileHash -LiteralPath $_.FullName -Algorithm SHA256 } |
  Select-Object Path, Hash |
  Export-Csv .\hashes.csv -NoTypeInformation -Encoding UTF8

Des fichiers qui semblent identiques par leur seul nom peuvent différer par leur contenu. Pour les fichiers distribués, les sauvegardes et les migrations, conserver les valeurs de hachage facilite grandement la vérification.

16. Envoyer vers le presse-papiers — Set-Clipboard

Quand vous voulez coller des résultats de commande dans un e-mail ou une messagerie, les envoyer vers le presse-papiers est pratique.

Get-Service |
  Select-Object Name, Status |
  ConvertTo-Csv -NoTypeInformation |
  Set-Clipboard

Pour voir le contenu du presse-papiers :

Get-Clipboard

Pour obtenir un format délimité par des tabulations à coller dans Excel, définissez le délimiteur de ConvertTo-Csv sur une tabulation.

Get-Process |
  Select-Object Name, Id, CPU |
  ConvertTo-Csv -NoTypeInformation -Delimiter "`t" |
  Set-Clipboard

Si vous voulez seulement partager un résultat temporairement, c’est plus simple que de créer un fichier à chaque fois. Mais si vous voulez le conserver comme preuve, enregistrez-le dans un fichier avec Export-Csv.

17. Afficher à l’écran tout en enregistrant dans un fichier — Tee-Object

Quand vous voulez voir des résultats à l’écran tout en les enregistrant également dans un fichier, utilisez Tee-Object.

Get-Process |
  Sort-Object -Property WorkingSet -Descending |
  Select-Object -First 10 Name, Id, WorkingSet |
  Tee-Object -FilePath .\top-process.txt

Tee-Object envoie les résultats du pipeline dans deux directions.

Afficher à l'écran
Enregistrer aussi dans un fichier

Il convient à l’usage « regarder tout en enregistrant » pendant une investigation. Si vous voulez ouvrir les données plus tard dans Excel, en revanche, Export-Csv est plus facile à utiliser.

Get-Process |
  Sort-Object -Property WorkingSet -Descending |
  Select-Object -First 10 Name, Id, WorkingSet |
  Export-Csv .\top-process.csv -NoTypeInformation -Encoding UTF8

Retenez : Tee-Object pour l’écran, Export-Csv pour conserver des données tabulaires, et cela reste clair.

18. Conserver un journal de travail — Start-Transcript

Pour enregistrer une séquence d’opérations, utilisez Start-Transcript.

Start-Transcript -Path .\work-log.txt

Les commandes exécutées après cela, ainsi que la sortie à l’écran, sont enregistrées.

Terminez-le.

Stop-Transcript

Dans un travail d’investigation, vous voudrez plus tard vérifier des points comme :

Quelles commandes ont été exécutées
Dans quel dossier le travail a eu lieu
Quels ont été les résultats
Si des erreurs sont survenues

Utiliser Start-Transcript sert d’assurance pour les moments où vous oubliez de prendre des notes de travail. Soyez toutefois prudent lorsque le travail affiche à l’écran des informations qui ne doivent pas être enregistrées, comme des mots de passe ou des jetons.

19. Lire un CSV et filtrer selon une condition

Le CSV revient constamment dans les données métier.

Par exemple, supposons que vous ayez le fichier users.csv suivant.

Name,Department,Enabled
Suzuki,Sales,true
Tanaka,Accounting,false
Sato,Sales,true

Lisez-le.

Import-Csv .\users.csv

Voyez uniquement les personnes dont le département est Sales.

Import-Csv .\users.csv |
  Where-Object { $_.Department -eq "Sales" }

Exportez uniquement les utilisateurs actifs vers un CSV séparé.

Import-Csv .\users.csv |
  Where-Object { $_.Enabled -eq "true" } |
  Export-Csv .\enabled-users.csv -NoTypeInformation -Encoding UTF8

Les valeurs CSV sont généralement traitées comme des chaînes de caractères ; ainsi, lors de la comparaison de true / false ou de nombres, pensez à une conversion de type si nécessaire.

Par exemple, pour ne voir que les lignes avec un score de 80 ou plus :

Import-Csv .\scores.csv |
  Where-Object { [int]$_.Score -ge 80 }

20. Consulter des valeurs de configuration JSON

Le JSON est couramment utilisé dans les fichiers de configuration et les API Web.

$config = Get-Content .\settings.json -Raw | ConvertFrom-Json
$config

Vous pouvez aussi consulter uniquement une valeur spécifique.

$config.Database.Host

Un exemple de modification d’une valeur puis d’enregistrement dans un fichier séparé :

$config.Database.Host = "db01"
$config |
  ConvertTo-Json -Depth 10 |
  Set-Content .\settings.updated.json -Encoding UTF8

Lorsque vous travaillez avec du JSON, Get-Content -Raw est le choix courant. Avec -Raw, le fichier entier est lu comme une seule chaîne de caractères, ce qui est plus clair pour manipuler du JSON sur plusieurs lignes.

21. Consulter les variables d’environnement

Les variables d’environnement reviennent souvent pour les paramètres d’application et les vérifications de chemin.

Voir la liste.

Get-ChildItem Env:

Voir le nom de l’utilisateur actuel.

$env:USERNAME

Voir le dossier temporaire.

$env:TEMP

Fractionner PATH pour la lisibilité.

$env:PATH -split ";"

Définir une variable d’environnement pour la session PowerShell actuelle uniquement.

$env:APP_MODE = "Development"

Ce réglage n’est effectif qu’à l’intérieur de la session PowerShell actuellement ouverte.

Pour la rendre persistante en tant que variable d’environnement utilisateur, procédez ainsi :

[Environment]::SetEnvironmentVariable("APP_MODE", "Development", "User")

Il s’agit d’une opération qui modifie l’environnement ; sur les PC d’entreprise et les serveurs de production, confirmez donc l’étendue de l’impact avant de l’effectuer.

22. Vérifier votre profil

PowerShell dispose d’un profil chargé au démarrage.

Vérifiez son emplacement.

$PROFILE

Vérifiez s’il existe.

Test-Path $PROFILE

Pour le créer :

New-Item -ItemType File -Path $PROFILE -Force

Ouvrez-le dans le Bloc-notes.

notepad $PROFILE

Placer les paramètres et fonctions fréquemment utilisés dans votre profil est pratique. Cependant, y écrire trop de traitements complexes ralentit le démarrage de PowerShell et rend les choses difficiles à reproduire dans d’autres environnements ; nous recommandons donc, au début, de vous limiter aux chemins fréquemment utilisés et aux réglages d’affichage.

23. Consulter les processus

Dans l’investigation des processus, le premier réflexe consiste généralement à regarder les plus gros consommateurs de mémoire.

Get-Process |
  Sort-Object -Property WorkingSet -Descending |
  Select-Object -First 10 Name, Id, @{Name="MemoryMB"; Expression={ [math]::Round($_.WorkingSet / 1MB, 1) }}

Filtrer par un nom spécifique.

Get-Process -Name notepad -ErrorAction SilentlyContinue

Pour arrêter un processus, ne l’exécutez pas directement — confirmez d’abord avec -WhatIf.

Stop-Process -Name notepad -WhatIf

Si tout semble correct, exécutez.

Stop-Process -Name notepad

Dans les environnements de production, arrêter un processus peut affecter les opérations métier. Avant de l’arrêter, confirmez la cible, les utilisateurs et la méthode de récupération.

24. Consulter les services

Voir la liste des services.

Get-Service

Pour ne voir que les services arrêtés :

Get-Service |
  Where-Object { $_.Status -eq "Stopped" }

Trouver les services configurés en démarrage automatique mais non en cours d’exécution.

Get-Service |
  Where-Object { $_.StartType -eq "Automatic" -and $_.Status -ne "Running" } |
  Select-Object Name, DisplayName, Status, StartType

Lors du redémarrage d’un service, confirmez également d’abord la cible.

Get-Service -Name "Spooler"

Répétez.

Restart-Service -Name "Spooler" -WhatIf

Les opérations sur les services ont un impact important ; confirmez donc la fenêtre de maintenance et la procédure de récupération avant d’exécuter.

25. Consulter les journaux d’événements

Dans l’investigation Windows, consulter les journaux d’événements revient fréquemment.

Voir les 100 entrées les plus récentes du journal System.

Get-WinEvent -LogName System -MaxEvents 100 |
  Select-Object TimeCreated, ProviderName, Id, LevelDisplayName, Message

Se limiter aux seules erreurs et avertissements.

Get-WinEvent -LogName System -MaxEvents 500 |
  Where-Object { $_.LevelDisplayName -in @("Error", "Warning") } |
  Select-Object TimeCreated, ProviderName, Id, LevelDisplayName, Message

Voir uniquement les erreurs des dernières 24 heures.

$start = (Get-Date).AddHours(-24)

Get-WinEvent -FilterHashtable @{ LogName = "System"; StartTime = $start } |
  Where-Object { $_.LevelDisplayName -eq "Error" } |
  Select-Object TimeCreated, ProviderName, Id, Message

Pour conserver les résultats d’investigation dans un CSV :

Get-WinEvent -LogName System -MaxEvents 500 |
  Where-Object { $_.LevelDisplayName -in @("Error", "Warning") } |
  Select-Object TimeCreated, ProviderName, Id, LevelDisplayName, Message |
  Export-Csv .\system-events.csv -NoTypeInformation -Encoding UTF8

Les journaux d’événements grossissent facilement ; il est donc important de restreindre la plage avec -MaxEvents ou une fenêtre temporelle.

26. Vérifier le réseau

Pour les vérifications de connectivité, utilisez Test-Connection.

Test-Connection example.com -Count 4

Pour vérifier la connectivité d’un port TCP sous Windows, Test-NetConnection est pratique.

Test-NetConnection example.com -Port 443

Pour vérifier la résolution DNS :

Resolve-DnsName example.com

Dans l’investigation réseau, isolez le problème ainsi :

Le nom peut-il être résolu
L'IP est-elle joignable
Le port cible est-il ouvert
Y a-t-il une interférence d'un proxy ou d'un pare-feu

Plutôt que de tout juger avec PowerShell seul, il fonctionne bien comme point d’entrée du processus d’isolation.

27. Consulter des résultats Web

Pour récupérer des pages Web, utilisez Invoke-WebRequest.

Invoke-WebRequest https://example.com |
  Select-Object StatusCode, StatusDescription

Pour traiter des résultats d’API JSON, Invoke-RestMethod est pratique.

Invoke-RestMethod https://api.github.com/repos/PowerShell/PowerShell |
  Select-Object full_name, stargazers_count, forks_count

Les résultats d’API peuvent généralement être manipulés comme des objets PowerShell dès le départ, ce qui les rend faciles à combiner avec Select-Object et Where-Object.

Pour l’investigation d’API internes également, commencez par des requêtes GET en lecture seule.

Lorsque vous manipulez des identifiants ou des jetons, faites attention à l’affichage à l’écran et à ce qui est enregistré dans le transcript.

28. Mesurer le temps d’exécution — Measure-Command

Quand vous voulez savoir combien de temps prend un traitement, utilisez Measure-Command.

Measure-Command {
  Get-ChildItem C:\Windows -File -Recurse -ErrorAction SilentlyContinue |
    Measure-Object
}

Le résultat inclut TotalSeconds et TotalMilliseconds.

$result = Measure-Command {
  Get-ChildItem . -File -Recurse | Measure-Object
}

$result.TotalSeconds

Quand vous voulez accélérer un script, mesurer le temps plutôt que de se fier à une impression est important. Cependant, les résultats varient selon le nombre de fichiers, l’état du disque et l’état du réseau ; ne jugez donc pas à partir d’une seule exécution, mais vérifiez plusieurs fois.

29. Exécuter un traitement long en arrière-plan — Start-Job

Pour exécuter une investigation longue comme une tâche séparée, utilisez Start-Job.

$job = Start-Job -ScriptBlock {
  Get-ChildItem C:\Windows -File -Recurse -ErrorAction SilentlyContinue |
    Measure-Object
}

Voir l’état de la tâche.

Get-Job

Récupérer les résultats.

Receive-Job $job

Supprimer les tâches devenues inutiles.

Remove-Job $job

Start-Job est pratique, mais il n’est pas nécessaire de l’utiliser massivement dès le départ. Exécutez d’abord normalement, et ne transformez en tâches que les traitements lents — cela reste plus clair.

30. Utiliser l’historique des commandes

Pour voir les commandes exécutées précédemment, utilisez Get-History.

Get-History

Rendre les lignes de commande seules plus lisibles.

Get-History |
  Select-Object Id, CommandLine

Réexécuter une entrée spécifique de l’historique.

Invoke-History 12

L’historique est pratique, mais il peut aussi réexécuter des commandes dangereuses. Lorsque vous réexécutez depuis l’historique des commandes de modification comme Remove-Item ou Stop-Process, vérifiez le contenu avant d’exécuter.

31. Consulter le détail d’une erreur — Get-Error

Dans PowerShell 7, Get-Error est disponible pour examiner en détail les erreurs récentes.

Get-Error

Pour ne voir que le message d’erreur le plus récent :

$Error[0].Exception.Message

Lorsqu’une erreur survient, ne vous contentez pas de regarder le texte rouge à l’écran — vérifiez les points suivants :

Quelle commande a échoué
Sur quel chemin ou quelle cible elle a échoué
S'il s'agit d'un problème de droits
Si le fichier n'existe pas
S'il s'agit d'un problème réseau ou de verrouillage

Pour conserver les résultats d’investigation, combinez avec Start-Transcript et Export-Csv.

32. Opérateurs de comparaison fréquemment utilisés

Les opérateurs de comparaison reviennent constamment avec Where-Object.

Exemples :

Get-ChildItem . -File |
  Where-Object { $_.Length -gt 10MB }

Get-Service |
  Where-Object { $_.Status -in @("Running", "Paused") }

Get-ChildItem . -File |
  Where-Object { $_.Name -match "\.log$" }

Au début, -eq, -ne, -gt, -lt et -like seuls suffisent. Une fois à l’aise, -match et -in facilitent l’écriture des conditions.

33. Petites recettes pratiques

À partir d’ici, voici des exemples directement réutilisables dans le travail quotidien.

Voir le nombre de fichiers par extension

Get-ChildItem C:\Work -File -Recurse |
  Group-Object -Property Extension -NoElement |
  Sort-Object -Property Count -Descending

À utiliser quand vous voulez un aperçu rapide du contenu d’un dossier.

Voir les 20 plus gros fichiers

Get-ChildItem C:\Work -File -Recurse |
  Sort-Object -Property Length -Descending |
  Select-Object -First 20 FullName, @{Name="SizeMB"; Expression={ [math]::Round($_.Length / 1MB, 2) }}

Couramment utilisé dans l’investigation de l’espace disque.

Voir les fichiers modifiés dans les dernières 24 heures

$since = (Get-Date).AddHours(-24)

Get-ChildItem C:\Work -File -Recurse |
  Where-Object { $_.LastWriteTime -ge $since } |
  Select-Object FullName, Length, LastWriteTime

Utile après un incident pour voir quels fichiers ont été modifiés.

Transformer les lignes de journal contenant ERROR en CSV

Select-String -Path C:\App\Logs\*.log -Pattern "ERROR" |
  Select-Object Path, LineNumber, Line |
  Export-Csv .\error-lines.csv -NoTypeInformation -Encoding UTF8

Facilite le partage des résultats d’investigation.

Voir 2 lignes avant et après chaque ERROR

Select-String -Path C:\App\Logs\*.log -Pattern "ERROR" -Context 2

À utiliser quand vous voulez le contexte autour de la cause.

Voir les processus consommant le plus de mémoire

Get-Process |
  Sort-Object -Property WorkingSet -Descending |
  Select-Object -First 10 Name, Id, @{Name="MemoryMB"; Expression={ [math]::Round($_.WorkingSet / 1MB, 1) }}

Voir les services configurés en démarrage automatique mais arrêtés

Get-Service |
  Where-Object { $_.StartType -eq "Automatic" -and $_.Status -ne "Running" } |
  Select-Object Name, DisplayName, Status, StartType

Transformer les erreurs du journal System en CSV

Get-WinEvent -LogName System -MaxEvents 500 |
  Where-Object { $_.LevelDisplayName -eq "Error" } |
  Select-Object TimeCreated, ProviderName, Id, Message |
  Export-Csv .\system-errors.csv -NoTypeInformation -Encoding UTF8

Envoyer les résultats d’une commande vers le presse-papiers

Get-Service |
  Select-Object Name, DisplayName, Status |
  ConvertTo-Csv -NoTypeInformation |
  Set-Clipboard

Pratique pour coller dans un e-mail ou une messagerie.

Comparer des listes de fichiers avant et après un travail

Get-ChildItem C:\Work -File |
  Select-Object -ExpandProperty Name |
  Set-Content .\before.txt -Encoding UTF8

Reprenez-la après le travail.

Get-ChildItem C:\Work -File |
  Select-Object -ExpandProperty Name |
  Set-Content .\after.txt -Encoding UTF8

Comparez.

Compare-Object (Get-Content .\before.txt) (Get-Content .\after.txt)

Voir la taille totale d’un dossier en Go

$size = Get-ChildItem C:\Work -File -Recurse |
  Measure-Object -Property Length -Sum

[math]::Round($size.Sum / 1GB, 2)

34. Précautions lors de la combinaison avec des commandes de modification

La majeure partie de ce que nous avons vu jusqu’ici est en lecture seule, et avec ces seules commandes, vous pouvez expérimenter assez librement. Voici, en revanche, des commandes de modification.

Utilisez les commandes de modification dans cet ordre :

1. Regarder les cibles avec des commandes Get-*
2. Filtrer avec Where-Object
3. Vérifier la liste des cibles avec Select-Object
4. Les compter avec Measure-Object
5. Conserver une trace avec Export-Csv si nécessaire
6. Faire une répétition avec -WhatIf lorsque c'est possible
7. Exécuter

Par exemple, la suppression d’anciens fichiers .tmp.

Regardez d’abord les cibles.

$limit = (Get-Date).AddDays(-30)

$targets = Get-ChildItem C:\Temp -Filter *.tmp -File -Recurse |
  Where-Object { $_.LastWriteTime -lt $limit }

$targets |
  Select-Object FullName, Length, LastWriteTime

Comptez-les.

$targets | Measure-Object

Conservez-les dans un CSV.

$targets |
  Select-Object FullName, Length, LastWriteTime |
  Export-Csv .\delete-targets.csv -NoTypeInformation -Encoding UTF8

Confirmez ce qui serait supprimé.

$targets | Remove-Item -WhatIf

Si tout semble correct, exécutez.

$targets | Remove-Item

Le simple fait de respecter ce déroulement réduit considérablement les incidents.

35. Comment les retenir

Essayer de mémoriser les commandes une à une est difficile ; il est plus facile de les retenir par objectif.

36. Conclusion

PowerShell est puissant une fois que vous savez écrire des scripts. Cependant, dans le travail réel, ce qui est le plus utilisé est, peut-être étonnamment, des combinaisons de petites commandes.

Compter
Trier
Regrouper
Comparer
Rechercher
Extraire
Enregistrer
Envoyer vers le presse-papiers
Conserver un journal de travail

Pouvoir faire simplement cela rend le travail quotidien considérablement plus facile. Il n’est pas nécessaire de viser dès le départ une automatisation complexe. Commencez par pouvoir observer précisément la situation avec des commandes en lecture seule, puis, sur cette base, utilisez des commandes de modification comme Copy-Item, Move-Item, Remove-Item et Restart-Service uniquement en cas de besoin.

L’astuce pour utiliser PowerShell en toute sécurité tient dans cet ordre :

Regarder → Compter → Mettre en forme → Enregistrer → Répéter → Exécuter

Intériorisez ce schéma, et PowerShell cesse d’être « un écran noir où l’on tape des commandes » pour devenir un outil pratique qui soutient votre investigation, votre organisation et votre reporting au quotidien.

Articles associés

Articles récents partageant les mêmes étiquettes, pour approfondir des sujets proches.

Sujets associés

Ces pages replacent le sujet dans un contexte plus large de services et de décisions.

Services liés à ce sujet

Cet article est directement lié aux services suivants.

Questions fréquentes

Questions souvent posées lors d’une consultation sur le sujet de cet article.

Comment vérifier le nombre de fichiers et la taille totale avec PowerShell ?

Redirigez le résultat de Get-ChildItem vers Measure-Object. Le nombre de fichiers apparaît dans la propriété Count du résultat, et si vous voulez inclure les sous-dossiers, ajoutez -Recurse. La taille totale s'obtient en agrégeant avec Measure-Object -Property Length -Sum ; comme le résultat en octets est peu lisible tel quel, le convertir en Go avec une expression du type [math]::Round($size.Sum / 1GB, 2) le rend plus lisible. En ajoutant -Average ou -Maximum, vous pouvez aussi obtenir la moyenne et le maximum en une seule fois.

Quelle est la différence entre -ExpandProperty de Select-Object et une spécification normale ?

Select-Object Name renvoie « un tableau (objet) possédant une colonne Name », tandis que Select-Object -ExpandProperty Name renvoie « la valeur de Name elle-même ». Si vous souhaitez exporter en CSV, la spécification normale, qui conserve la colonne, est adaptée ; si vous voulez transmettre uniquement les valeurs à une autre commande, à un traitement de chaînes de caractères ou à un fichier texte, -ExpandProperty est plus facile à manipuler. Le choix se fait selon l'objectif visé.

Pourquoi ne faut-il pas utiliser Format-Table avant Export-Csv ?

Format-Table et Format-List sont des commandes destinées à l'affichage à l'écran ; elles transforment la sortie en objets de mise en forme, ce qui empêche ensuite un export CSV ou un traitement correct par la suite. Pour exporter en CSV ou traiter le résultat avec la commande suivante, sélectionnez les colonnes avec Select-Object avant de transmettre le résultat à Export-Csv. Retenez la règle : « pour un simple affichage à l'écran, les commandes Format-*, pour une utilisation ultérieure, Select-Object », et vous ne vous tromperez pas.

Existe-t-il une procédure pour utiliser en toute sécurité des commandes de modification comme Remove-Item ?

Ne les exécutez pas directement : commencez par examiner les cibles avec une commande Get-*, filtrez-les avec Where-Object, vérifiez la liste des cibles avec Select-Object, comptez-les avec Measure-Object, et conservez une trace avec Export-Csv si nécessaire. Ensuite, pour les commandes qui prennent en charge -WhatIf, faites une répétition pour confirmer le plan de suppression ou de déplacement, et exécutez seulement si tout est correct. Le simple fait de respecter cet ordre réduit considérablement les incidents.

Profil de l’auteur

Page de présentation de l’auteur de l’article.

Go Komura

Représentant de KomuraSoft LLC

Spécialisé dans le développement de logiciels Windows, le conseil technique et l’analyse de pannes, notamment pour les systèmes existants et les incidents difficiles à reproduire.