PowerShell pour débutants : cmdlets, pipeline et premiers scripts pour automatiser Windows

PowerShell est l’interpréteur de commandes et le langage de script de Microsoft : il permet d’administrer Windows, d’interroger le système et d’automatiser des tâches répétitives à l’aide de commandes appelées cmdlets, que l’on enchaîne dans un pipeline. Sa particularité est de manipuler des objets plutôt que du texte, ce qui rend les scripts plus fiables et plus lisibles.

Ce guide s’adresse aux techniciens, administrateurs, développeurs et utilisateurs avancés qui débutent en PowerShell. Vous y apprendrez à installer et configurer votre environnement, à comprendre les cmdlets et le pipeline, puis à écrire vos premiers scripts avec variables, conditions, boucles et fonctions.

Qu’est-ce que PowerShell ?

PowerShell est un shell en ligne de commande et un langage de script construit sur .NET. Chaque commande renvoie des objets, dotés de propriétés et de méthodes, que l’on peut filtrer, trier ou exporter sans découper du texte. Il sert à administrer Windows, les serveurs, le cloud Microsoft et, depuis la version 7, Linux et macOS.

Deux versions coexistent aujourd’hui :

• Windows PowerShell 5.1, intégré à Windows 10 et 11, qui n’évolue plus mais reste maintenu ;
• PowerShell 7, open source et multiplateforme, qui reçoit les nouveautés et s’installe à côté de la version 5.1.

Pourquoi la logique « objet » change tout

Dans un shell classique, une commande renvoie des lignes de texte. Pour extraire une information, il faut découper ce texte en colonnes, avec le risque qu’un changement de format ou de langue casse le script. Dans PowerShell, Get-Service renvoie des objets « service » qui possèdent des propriétés (Name, Status, StartType) et des méthodes (Start, Stop, Refresh).

Concrètement, vous ne cherchez pas le mot « Running » dans une ligne : vous testez la propriété Status. Le résultat est identique sur un Windows en français ou en anglais, et il ne dépend pas de la largeur de la console. C’est ce qui rend les scripts PowerShell plus robustes et plus faciles à maintenir sur la durée. C’est aussi pourquoi l’affichage à l’écran n’est qu’une représentation simplifiée : un objet contient souvent bien plus de propriétés que celles affichées par défaut.

Pourquoi apprendre PowerShell ?

PowerShell est l’outil de référence dès qu’il s’agit d’automatiser Windows et l’écosystème Microsoft :

• Automatiser les tâches répétitives : nettoyer des dossiers, renommer des centaines de fichiers, générer un rapport chaque matin.
• Administrer à grande échelle : créer des comptes, vérifier des services ou interroger plusieurs postes en une seule commande.
• Diagnostiquer : espace disque, processus gourmands, journaux d’événements, configuration réseau.
• Piloter le cloud Microsoft : des modules dédiés existent pour Microsoft 365, Azure ou Exchange Online.
• Documenter et fiabiliser : un script remplace une procédure manuelle sujette aux oublis et aux erreurs de saisie.

Installer et configurer son environnement PowerShell

Vérifier la version installée

Ouvrez Windows PowerShell depuis le menu Démarrer (ou le Terminal Windows), puis tapez :

$PSVersionTable

La ligne PSVersion indique la version. Si elle commence par 5.1, vous utilisez Windows PowerShell.

Installer PowerShell 7

La méthode la plus simple passe par le gestionnaire de paquets winget, intégré aux versions récentes de Windows :

winget install --id Microsoft.PowerShell --source winget

PowerShell 7 se lance ensuite avec la commande pwsh, ou depuis un nouvel onglet du Terminal Windows. Vous pouvez aussi télécharger l’installeur depuis la documentation officielle de Microsoft sur learn.microsoft.com.

Autoriser l’exécution de vos scripts

Par défaut, les postes Windows bloquent l’exécution des fichiers .ps1. Pour autoriser vos propres scripts tout en exigeant une signature pour ceux téléchargés sur Internet, réglez la stratégie pour votre seul compte :

Get-ExecutionPolicy
Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser

La stratégie d’exécution est une sécurité contre les exécutions accidentelles, pas une protection absolue. Ne lancez jamais un script dont vous ne comprenez pas le contenu.

Choisir son éditeur

Pour écrire des scripts, installez Visual Studio Code avec l’extension PowerShell : coloration, complétion automatique et débogage pas à pas. Windows PowerShell ISE, présent sur Windows, reste pratique pour vos premiers essais, mais il ne prend en charge que Windows PowerShell 5.1.

PowerShell débutant : maîtriser les bases pas à pas

Étape 1 — Comprendre les cmdlets et la structure Verbe-Nom

Toutes les cmdlets suivent la structure Verbe-Nom. Le verbe dit ce que l’on fait (Get, Set, New, Remove, Start, Stop), le nom sur quoi on agit (Process, Service, Item, Content).

Get-Process                      # liste les processus
Get-Service                      # liste les services
Get-ChildItem C:\Windows         # liste le contenu d'un dossier
Get-Content .\notes.txt          # lit un fichier
Stop-Process -Name notepad       # ferme le Bloc-notes

Cette logique rend PowerShell très prévisible : si Get-Service existe, vous pouvez deviner l’existence de Start-Service et Stop-Service. Les paramètres commencent par un tiret (-Name), et la touche Tab complète noms de cmdlets et de paramètres.

Étape 2 — Utiliser l’aide intégrée

Trois commandes suffisent pour trouver seul la bonne cmdlet :

Get-Command -Noun *Service*          # toutes les cmdlets qui agissent sur des services
Get-Help Get-Service -Examples       # exemples d'utilisation
Get-Help Get-Service -Full           # aide complète
Update-Help                          # télécharge l'aide à jour (console administrateur sous 5.1)

Notre conseil : avant de chercher un exemple sur Internet, lancez Get-Help avec -Examples. Les exemples officiels sont fiables et adaptés à votre version.

Étape 3 — Créer des alias

Un alias est un raccourci vers une cmdlet. PowerShell en fournit déjà beaucoup : ls, dir et gci pointent vers Get-ChildItem, cd vers Set-Location, cat vers Get-Content.

Get-Alias                            # liste les alias existants
Get-Alias -Definition Get-ChildItem  # alias d'une cmdlet donnée
New-Alias -Name np -Value notepad    # crée un alias pour la session

Un alias créé ainsi disparaît à la fermeture de la console. Pour le conserver, ajoutez la ligne dans votre profil (notepad $PROFILE). Utilisez les alias pour taper plus vite en console, mais écrivez les noms complets des cmdlets dans vos scripts : ils restent lisibles par vos collègues.

Étape 4 — Maîtriser le pipeline

Le pipeline | transmet les objets d’une commande à la suivante. C’est la fonctionnalité centrale de PowerShell :

# Les 5 processus qui consomment le plus de temps processeur
Get-Process | Sort-Object CPU -Descending | Select-Object -First 5 Name, CPU

# Les services arrêtés
Get-Service | Where-Object Status -eq 'Stopped'

# Les fichiers de plus de 100 Mo du dossier Téléchargements
Get-ChildItem $HOME\Downloads -File | Where-Object Length -gt 100MB

# Exporter la liste des services dans un fichier CSV
Get-Service | Select-Object Name, Status, StartType |
    Export-Csv .\services.csv -NoTypeInformation -Encoding UTF8

Pour savoir quelles propriétés un objet possède, envoyez-le vers Get-Member : Get-Service | Get-Member affiche toutes ses propriétés et méthodes.

Étape 5 — Utiliser les opérateurs de comparaison

PowerShell n’utilise pas =, < ou > pour comparer, mais des opérateurs précédés d’un tiret :

Opérateur	Signification	Exemple
-eq / -ne	Égal / différent	$statut -eq 'Running'
-gt / -ge	Supérieur / supérieur ou égal	$taille -gt 100MB
-lt / -le	Inférieur / inférieur ou égal	$age -lt 30
-like	Correspondance avec jokers	$nom -like 'rapport*'
-match	Correspondance avec une expression régulière	$ligne -match 'ERROR\s\d+'
-contains / -in	Présence dans une collection	$liste -contains 'Paris'
-and / -or / -not	Opérateurs logiques	($a -gt 1) -and ($b -lt 5)

Par défaut, les comparaisons de texte ne tiennent pas compte de la casse. Ajoutez un c pour les rendre sensibles à la casse : -ceq, -clike.

Étape 6 — Manipuler les propriétés et les méthodes des objets

Une fois qu’un objet est stocké dans une variable, on accède à ses propriétés avec un point, et on appelle ses méthodes avec des parenthèses :

$service = Get-Service -Name Spooler
$service.Status                  # propriété : état du service d'impression
$service.DisplayName             # propriété : nom affiché
$fichier = Get-Item .
otes.txt
$fichier.Length                  # taille en octets
$fichier.LastWriteTime           # date de dernière modification
"bonjour".ToUpper()              # méthode d'une chaîne : BONJOUR
(Get-Date).AddDays(30)           # méthode d'une date : dans 30 jours

Pour afficher toutes les propriétés d’un objet, et pas seulement celles de l’affichage par défaut, utilisez Select-Object * ou Format-List *. En formation, c’est souvent le déclic : la plupart des informations que l’on croyait introuvables sont en réalité déjà présentes dans l’objet, il suffisait de les afficher.

Écrire un script PowerShell : variables, conditions, boucles et fonctions

Déclarer, typer et convertir des variables

Une variable commence par $. PowerShell devine son type, mais vous pouvez l’imposer entre crochets, ce qui rend vos scripts plus robustes :

$nom = "Serveur01"               # chaîne de caractères
[int]$seuil = 20                 # entier imposé
$date = Get-Date                 # objet date
$nombre = [int]"42"              # conversion explicite d'une chaîne en entier
$seuil.GetType().Name            # affiche le type : Int32

# Constante : ne pourra plus être modifiée pendant la session
Set-Variable -Name TVA -Value 0.2 -Option Constant

# Here-string : bloc de texte sur plusieurs lignes
$message = @"
Rapport du $(Get-Date -Format 'dd/MM/yyyy')
Serveur : $nom
"@

Dans une here-string, la ligne de fermeture "@ doit être placée en tout début de ligne. Les guillemets doubles remplacent les variables par leur valeur ; les guillemets simples affichent le texte tel quel. Les commentaires s’écrivent avec # sur une ligne, ou entre <# et #> sur plusieurs lignes.

Conditions : if, elseif, else et switch

$espaceLibre = (Get-PSDrive C).Free / 1GB

if ($espaceLibre -lt 10) {
    Write-Warning "Espace critique : $([math]::Round($espaceLibre, 1)) Go libres"
}
elseif ($espaceLibre -lt 30) {
    Write-Host "Espace à surveiller"
}
else {
    Write-Host "Espace disque correct"
}

$jour = (Get-Date).DayOfWeek
switch ($jour) {
    'Monday'   { 'Sauvegarde complète' }
    'Saturday' { 'Maintenance' }
    'Sunday'   { 'Aucune tâche' }
    default    { 'Sauvegarde incrémentale' }
}

Pour formater proprement une chaîne, utilisez l’opérateur -f : "{0} a {1} Go libres" -f $nom, 42 produit « Serveur01 a 42 Go libres ».

Tableaux et boucles for et foreach

$serveurs = @('SRV01', 'SRV02', 'SRV03')
$serveurs += 'SRV04'                 # ajoute un élément
$serveurs.Count                      # nombre d'éléments
$serveurs[0]                         # premier élément

for ($i = 0; $i -lt $serveurs.Count; $i++) {
    "Serveur n°$($i + 1) : $($serveurs[$i])"
}

foreach ($serveur in $serveurs) {
    "Vérification de $serveur"
}

# Équivalent dans le pipeline
$serveurs | ForEach-Object { "Traitement de $_" }

Dans le pipeline, $_ (ou $PSItem) désigne l’objet en cours de traitement.

Créer des fonctions professionnelles

Une fonction transforme un bloc de code en outil réutilisable, qui se comporte comme une vraie cmdlet. L’attribut [CmdletBinding()] active notamment le paramètre -Verbose, et les attributs de validation refusent les valeurs incorrectes avant même l’exécution :

function Get-EspaceDisque {
    <#
    .SYNOPSIS
    Indique le pourcentage d'espace libre d'un lecteur et alerte sous un seuil.
    #>
    [CmdletBinding()]
    param(
        [Parameter(Mandatory)]
        [ValidatePattern('^[A-Z]$')]
        [string]$Lecteur,

        [ValidateRange(1, 99)]
        [int]$Seuil = 15
    )

    Write-Verbose "Analyse du lecteur $Lecteur (seuil : $Seuil %)"
    $disque = Get-PSDrive -Name $Lecteur -PSProvider FileSystem
    $total = $disque.Used + $disque.Free
    $pourcentLibre = [math]::Round($disque.Free / $total * 100, 1)

    [PSCustomObject]@{
        Lecteur       = $Lecteur
        LibreGo       = [math]::Round($disque.Free / 1GB, 1)
        PourcentLibre = $pourcentLibre
        Alerte        = $pourcentLibre -lt $Seuil
    }
}

Get-EspaceDisque -Lecteur C -Verbose

La fonction renvoie un objet personnalisé plutôt que du texte : vous pouvez donc le trier, le filtrer ou l’exporter en CSV comme n’importe quel résultat de cmdlet. Nommez vos fonctions avec un verbe approuvé (la liste s’affiche avec Get-Verb) pour rester cohérent avec le reste de PowerShell.

Gérer les erreurs avec try et catch

Un script d’automatisation tourne souvent sans surveillance : il doit donc réagir proprement quand quelque chose échoue. Le bloc try / catch intercepte les erreurs, à condition qu’elles soient « bloquantes ». Pour les cmdlets, on le garantit avec -ErrorAction Stop :

try {
    Get-Content -Path C:\Rapports\inexistant.txt -ErrorAction Stop
}
catch {
    Write-Warning "Lecture impossible : $($_.Exception.Message)"
}
finally {
    Write-Verbose "Fin du traitement"
}

Le bloc finally s’exécute dans tous les cas, erreur ou non : il sert par exemple à fermer une connexion ou à écrire une ligne de journal.

Les bonnes pratiques d’écriture

Quelques règles simples rendent vos scripts lisibles et durables :

• donnez des noms explicites aux variables ($dossierSource plutôt que $d) ;
• commentez le « pourquoi », pas le « quoi » : le code dit déjà ce qu’il fait ;
• placez les valeurs susceptibles de changer (chemins, seuils) dans des paramètres plutôt qu’en dur dans le code ;
• testez toujours les actions destructrices avec -WhatIf avant de les exécuter réellement ;
• conservez vos scripts dans un dépôt versionné pour garder l’historique des modifications ;
• journalisez les actions importantes dans un fichier, pour pouvoir comprendre ce qui s’est passé après coup.

Automatiser Windows avec un script planifié

Enregistrez un script dans un fichier .ps1, par exemple un nettoyage des fichiers temporaires de plus de 7 jours :

# C:\Scripts\nettoyage.ps1
$dossier = "$env:TEMP"
$limite = (Get-Date).AddDays(-7)

Get-ChildItem -Path $dossier -File -Recurse -ErrorAction SilentlyContinue |
    Where-Object LastWriteTime -lt $limite |
    Remove-Item -WhatIf

Le paramètre -WhatIf affiche ce qui serait supprimé sans rien supprimer : c’est le réflexe de sécurité à adopter pour toute commande destructrice. Une fois le résultat vérifié, retirez-le. Pour exécuter le script chaque jour, créez une tâche planifiée :

$action  = New-ScheduledTaskAction -Execute "powershell.exe" -Argument "-NoProfile -File C:\Scripts\nettoyage.ps1"
$trigger = New-ScheduledTaskTrigger -Daily -At 7am
Register-ScheduledTask -TaskName "Nettoyage TEMP" -Action $action -Trigger $trigger

La création d’une tâche planifiée peut demander une console ouverte en administrateur. Vérifiez ensuite son bon fonctionnement dans le Planificateur de tâches de Windows, où l’historique indique la date de la dernière exécution et son résultat. Notre conseil : faites écrire à votre script un petit fichier journal (date, nombre de fichiers traités, erreurs éventuelles), qui vous permettra de contrôler en un coup d’œil qu’il tourne bien chaque jour.

Pour des automatisations centrées sur les applications Microsoft 365 (courriels, fichiers SharePoint, approbations), un outil sans code comme Power Automate est souvent plus adapté. Et pour automatiser l’intérieur d’un classeur Excel, les macros VBA restent l’outil de référence.

Les erreurs fréquentes des débutants en PowerShell

Erreur ou message	Cause	Solution
« L’exécution de scripts est désactivée sur ce système »	Stratégie d’exécution restrictive	Set-ExecutionPolicy RemoteSigned -Scope CurrentUser
Le script n’est pas reconnu	Lancé sans son chemin	Taper .\script.ps1 depuis son dossier
= utilisé dans une condition	Confusion avec d’autres langages	Utiliser -eq, -gt, -lt…
Accès refusé	Console non lancée en administrateur	Ouvrir PowerShell avec « Exécuter en tant qu’administrateur »
Accents illisibles dans un fichier exporté	Encodage inadapté	Préciser -Encoding UTF8
Suppression involontaire	Commande destructrice lancée sans test	Toujours tester avec -WhatIf
Script illisible par les collègues	Alias et abréviations partout	Noms complets des cmdlets et des paramètres dans les scripts

PowerShell, CMD ou Bash : comparaison

Critère	Invite de commandes (CMD)	PowerShell	Bash
Système principal	Windows	Windows, et Linux et macOS avec PowerShell 7	Linux, macOS
Ce qui circule dans le pipeline	Texte	Objets .NET	Texte
Langage de script	Fichiers batch limités	Langage complet (fonctions, types, erreurs)	Langage complet orienté texte
Administration Windows	Basique	Complète	Limitée
Usage typique	Anciennes procédures	Administration et automatisation Microsoft	Serveurs Linux, DevOps

Si vous administrez aussi des serveurs Linux, notre guide des commandes Linux vous donnera les équivalents Bash. Et pour des traitements de données plus poussés, apprendre Python est un excellent complément.

Comment progresser en PowerShell ?

Voici un parcours réaliste pour devenir autonome :

1. Première heure : installation, cmdlets, aide intégrée, alias.
2. Deuxième heure : pipeline, Where-Object, Sort-Object, Select-Object, Get-Member, export CSV.
3. Semaine 1 : variables, conditions, tableaux et boucles dans de petits scripts.
4. Semaine 2 : fonctions avec paramètres validés, puis un script planifié qui répond à un vrai besoin de votre poste.

Pour être accompagné sur ce parcours, la formation PowerShell pour débutants d’EspritAcadémique propose 1 h 45 de vidéos pratiques, sans prérequis. Elle couvre notamment :

• l’installation, les cmdlets, les alias et les opérateurs de comparaison ;
• le pipeline et la manipulation des objets ;
• la déclaration, le typage et la conversion des variables, les here-strings et les constantes ;
• les conditions if, elseif, else et switch, et le formatage des chaînes ;
• les tableaux et les boucles for et foreach ;
• la création de fonctions structurées, avec Write-Verbose et validation des paramètres.

En résumé

PowerShell est l’outil d’automatisation de référence sous Windows. Retenez la structure Verbe-Nom des cmdlets, prenez le réflexe de Get-Help et Get-Member, et exploitez le pipeline objet pour filtrer et exporter vos données. Ajoutez ensuite variables, conditions, boucles et fonctions : en quelques heures de pratique, vous remplacerez vos tâches manuelles répétitives par des scripts fiables.