Cours PowerShell — pipeline d'objets, cmdlets, scripts sûrs avec pwsh sur macOS

Objectifs d'apprentissage

À la fin de ce cours, l'apprenant peut :

1. lancer pwsh sur macOS et dire ce qui le distingue de Windows PowerShell 5.1 ;
2. lire et écrire une commande au format Verb-Noun et la découvrir avec Get-Command, Get-Help et Get-Member ;
3. expliquer que le tube transporte des objets et non du texte, et en tirer parti ;
4. filtrer, sélectionner, trier et transformer avec Where-Object, Select-Object, Sort-Object et ForEach-Object ;
5. choisir un format d'affichage (Format-Table, Format-List) sans casser le pipeline ;
6. utiliser variables, types, tableaux et tables de hachage ;
7. écrire une fonction avancée avec [CmdletBinding()], des paramètres typés et de la validation ;
8. gérer les erreurs avec -ErrorAction, try/catch/finally ;
9. lire et écrire des fichiers, du JSON et du CSV ;
10. rendre un script prudent avec -WhatIf, -Confirm et SupportsShouldProcess ;
11. dire ce qu'est la politique d'exécution et pourquoi elle n'est pas une frontière de sécurité ;
12. évaluer un module de la PowerShell Gallery avant de l'installer, et traiter les secrets sans les écrire en clair ;
13. adopter l'habitude « lecture seule d'abord ».

Prérequis

• Savoir ouvrir Terminal et lire une commande avant de la valider (cours « Terminal macOS »).
• Notions de scripts shell (cours « Scripting shell et Python ») : utiles pour comparer, pas obligatoires.
• PowerShell 7 installé sur le Mac de Stéphane : non vérifié. Ce cours n'installe rien. La seule référence d'installation est la page officielle à lire : <https://learn.microsoft.com/en-us/powershell/scripting/install/install-powershell-on-macos (s’ouvre dans un nouvel onglet)> (le paquet macOS y est présenté comme signé et notarisé par Microsoft à partir des versions de mai 2026).
• Un dossier de test jetable. Aucun exercice ne demande de droits administrateur.

Parcours et chapitres

1. PowerShell 7 sur macOS et différences avec Windows PowerShell 5.1

PowerShell est un shell et un langage de script. Selon la page « Differences between Windows PowerShell 5.1 and PowerShell 7.x » :

La page indique que les différences de langage sont peu nombreuses ; les plus visibles sont la disponibilité et le comportement des cmdlets selon la plateforme, et les changements dus à .NET. Sur macOS, les cmdlets propres à Windows (registre, services Windows, WMI, etc.) ne sont pas disponibles : la liste exacte par cmdlet est non vérifiée.

D'après la page d'installation, après l'installation du paquet on lance pwsh depuis Terminal ; le profil utilisateur est lu dans ~/.config/powershell/profile.ps1, les modules utilisateur dans ~/.local/share/powershell/Modules, et PowerShell respecte la spécification XDG sur macOS. Les mises à jour se font en installant le nouveau paquet.

pwsh$PSVersionTable.PSVersion$PSVersionTable.OSexit

• Contexte : Terminal macOS, pwsh installé (non vérifié). Les lignes après pwsh se tapent dans la session PowerShell ; $PSVersionTable est une variable automatique décrite dans la documentation PowerShell (page non relue, voir « Points non vérifiés »).
• Droits : utilisateur normal.
• Effet : ouvre une session PowerShell, affiche la version et le système, puis ferme la session. Aucune modification.
• Vérification : la version affichée est celle de pwsh (et non celle de la documentation) ; c'est le chiffre à noter pour compléter ce cours.
• Retour arrière : sans objet (exit ferme la session).

Pour exécuter une seule commande sans session interactive : pwsh -NoProfile -Command "Get-Date" (option -NoProfile et -Command : usage courant, non vérifié sur la page de ligne de commande, non lue).

2. Cmdlets et convention Verb-Noun

Une cmdlet (« commandlet ») est une commande de PowerShell nommée Verbe-Nom : un verbe d'une liste approuvée, un nom au singulier, par exemple Get-Process, Get-ChildItem, Set-Location. La cohérence fait l'intérêt du langage : tous les Get-* lisent, tous les Remove-* suppriment. Les paramètres commencent par - et sont nommés (-Path, -Name). PowerShell ne distingue pas les majuscules des minuscules pour les cmdlets et leurs paramètres.

Cette table décrit l'usage courant ; la liste officielle des verbes approuvés (Get-Verb) n'a pas été relue : non vérifié.

Des alias existent (ls, dir, cat, ps, gci, %, ?). Utiles en interactif, à éviter dans un script : sur macOS et Linux, PowerShell 7 ne redéfinit pas certains alias pour laisser les commandes natives (ls, cat…) passer (comportement non vérifié dans les pages lues). Dans un script, écrire le nom complet.

3. Découvrir : Get-Command, Get-Help, Get-Member

Trois cmdlets suffisent pour explorer, sans rien modifier :

Get-Command -Verb Get -Noun Process*Get-Help Get-Process -ExamplesGet-Process | Get-Member -MemberType Property

• Contexte : session pwsh ; PowerShell 7.x (version non vérifiée). Le contenu complet de l'aide peut demander Update-Help : voir ci-dessous.
• Droits : utilisateur normal.
• Effet : la première liste les commandes qui lisent des processus, la deuxième affiche des exemples d'utilisation de Get-Process, la troisième liste les propriétés des objets processus. Aucune modification.
• Vérification : chaque commande affiche du texte ; si Get-Help ne montre que la syntaxe, l'aide complète n'est pas installée sur ce poste.
• Retour arrière : sans objet.
• Get-Command : trouve des commandes par nom, verbe, nom commun ou module (-Module).
• Get-Help <cmdlet> : syntaxe et description ; -Examples, -Detailed, -Full, -Online (ouvre la page web). Les pages « about_* » (Get-Help about_Pipelines) expliquent les concepts.
• Get-Member : liste les propriétés et méthodes d'un objet reçu par le tube ; c'est l'outil central pour comprendre ce qu'on manipule.
• Update-Help télécharge l'aide complète (accès réseau et écriture dans les dossiers d'aide, droits potentiellement élevés pour les modules du système : non vérifié). Ne pas le lancer sans l'avoir lu.

4. Le pipeline d'objets : la différence majeure

Dans un shell classique (bash, zsh), le tube | transporte du texte : on découpe des colonnes avec awk, cut, grep. Dans PowerShell, une cmdlet envoie des objets .NET, avec des propriétés nommées et typées ; l'étape suivante lit ces propriétés directement. D'après la documentation (about_Pipelines, page à relire), le tube passe les objets un à un à la commande suivante.

Comparaison :

Get-Process | Sort-Object CPU -Descending | Select-Object -First 5 Name, Id, CPU

• Contexte : session pwsh ; la propriété CPU des processus et son unité dépendent de la plateforme (non vérifié sur macOS).
• Droits : utilisateur normal ; certains processus d'autres utilisateurs peuvent exposer moins de propriétés.
• Effet : lit les processus, les trie par temps processeur décroissant, garde cinq objets et trois propriétés, puis les affiche. Aucune modification du système.
• Vérification : cinq lignes, trois colonnes (Name, Id, CPU) ; essayer | Get-Member après Get-Process pour voir toutes les propriétés.
• Retour arrière : sans objet.

L'équivalent shell exigerait de découper une colonne de texte par sa position : fragile. Ici, on trie sur une propriété.

5. Filtrer, sélectionner, trier, transformer

$_ (ou $PSItem) désigne l'objet courant dans un bloc de script. Opérateurs de comparaison : -eq, -ne, -gt, -lt, -ge, -le, -like (jokers), -match (expression régulière), -in, -contains, -and, -or, -not. Ils ne sont pas des symboles (==, >) : attention, > est la redirection de fichier, qui écrit un fichier.

Get-ChildItem -File | Where-Object { $_.Length -gt 1KB } | Sort-Object Length -Descending | Select-Object Name, Length

• Contexte : session pwsh, dossier de test contenant quelques fichiers synthétiques ; KB est un suffixe numérique du langage (1KB = 1024), non vérifié dans une page lue.
• Droits : lecture du dossier courant.
• Effet : liste les fichiers de plus d'un kilo-octet, du plus gros au plus petit, avec nom et taille. Aucune modification.
• Vérification : la colonne Length est décroissante et aucune valeur n'est inférieure à 1024 ; en cas de résultat vide, le dossier ne contient pas de fichier assez gros.
• Retour arrière : sans objet.

6. Formater et exporter

• Format-Table (ft), Format-List (fl) : mise en forme d'affichage pour l'œil, à placer en dernier.
• Out-String : transforme en texte (pour un message), à utiliser rarement.
• Out-File, Export-Csv, ConvertTo-Json, Out-GridView (graphique, Windows) : pour sortir des données ; vérifier leur disponibilité sous macOS.

Get-Process | Select-Object -First 3 Name, Id | Format-Table -AutoSizeGet-Process | Select-Object -First 3 Name, Id | Format-List

• Contexte : session pwsh.
• Droits : utilisateur normal.
• Effet : affiche trois processus en tableau, puis en liste (une propriété par ligne). Aucune modification.
• Vérification : même contenu, deux présentations.
• Retour arrière : sans objet.

7. Variables, types, tableaux et tables de hachage

Les variables commencent par $. Le typage est dynamique mais on peut contraindre avec un type entre crochets.

$nom = "demo"[int]$compte = 3$liste = @("a", "b", "c")$config = @{ Hote = "exemple.test"; Port = 8080 }$liste.Count$config.Port$nom.GetType().Name

• Contexte : session pwsh ; chaînes et valeurs synthétiques (example.test / exemple.test : nom réservé aux exemples).
• Droits : utilisateur normal.
• Effet : crée des variables en mémoire de la session (aucun fichier). @( ) crée un tableau, @{ } une table de hachage (clé = valeur) ; .Count, .Port et .GetType().Name lisent des valeurs.
• Vérification : 3, 8080 et String s'affichent.
• Retour arrière : Remove-Variable nom, compte, liste, config ou fermer la session. La syntaxe @(), @{} et le typage sont la connaissance usuelle du langage : non relue sur la page « about_Arrays » / « about_Hash_Tables ».

Points de vigilance :

• guillemets doubles "..." : expansion des variables ("Bonjour $nom") ; guillemets simples '...' : texte littéral. Pour un texte non fiable, préférer les guillemets simples.
• Une table de hachage [ordered]@{} conserve l'ordre ; [pscustomobject]@{ Nom = 'a'; Taille = 1 } crée un objet à propriétés nommées.
• Splatting : passer une table de hachage comme paramètres avec @params (rappelé par la page ShouldProcess lue : Remove-Item @RemoveSplat).
• $null, $true, $false sont les valeurs spéciales. Un résultat à un seul élément n'est pas un tableau : utiliser @(...) pour forcer un tableau.

8. Fonctions et paramètres

Une fonction avancée se déclare avec [CmdletBinding()] : elle gagne alors les paramètres communs (-Verbose, -ErrorAction, -WhatIf si demandé…). La validation des paramètres se fait par attributs. Exemple en lecture seule :

function Get-FichierVolumineux {    [CmdletBinding()]    param(        [Parameter(Mandatory)]        [ValidateScript({ Test-Path -LiteralPath $_ -PathType Container })]        [string]$Dossier,​        [ValidateRange(1, 1048576)]        [int]$TailleMinKo = 1024    )    Get-ChildItem -LiteralPath $Dossier -File |        Where-Object { $_.Length -ge ($TailleMinKo * 1KB) } |        Select-Object Name, Length}Get-FichierVolumineux -Dossier . -TailleMinKo 1

• Contexte : session pwsh ; PowerShell 7.x. [Parameter(Mandatory)], [ValidateScript], [ValidateRange] et -LiteralPath : usages décrits dans la documentation (pages « about_Functions_Advanced_Parameters » non relues ici : non vérifié).
• Droits : lecture du dossier passé en argument.
• Effet : déclare la fonction dans la session (mémoire) puis liste les fichiers d'au moins TailleMinKo kilo-octets. Aucune modification de fichier.
• Vérification : Get-FichierVolumineux -Dossier /dossier-qui-n-existe-pas est refusé par la validation avant l'exécution ; -TailleMinKo 0 est refusé par ValidateRange.
• Retour arrière : la fonction disparaît à la fermeture de la session (ou Remove-Item function:Get-FichierVolumineux).

À savoir :

• -LiteralPath traite le chemin tel quel (pas de joker) : plus sûr avec des noms contenant [ ou *.
• Nommer ses fonctions Verbe-Nom avec un verbe approuvé. Préférer retourner des objets plutôt qu'écrire du texte avec Write-Host (qui sert à l'affichage seulement).
• return n'est pas indispensable : tout ce qui est émis sur la sortie est retourné. Piège : une instruction qui renvoie un résultat non voulu pollue la sortie de la fonction.
• Un script a un bloc param() en tête, comme une fonction ; Set-StrictMode -Version Latest aide à détecter les variables non définies (comportement courant, non vérifié).

9. Gérer les erreurs

PowerShell distingue les erreurs non terminantes (la cmdlet continue, l'erreur est écrite sur le flux d'erreurs) et les erreurs terminantes (elles arrêtent l'instruction, voire le script). La page officielle about_Try_Catch_Finally (7.6) précise que try/catch attrape les erreurs terminantes de deux sortes (arrêtant l'instruction ou arrêtant le script).

• -ErrorAction Stop : transforme une erreur non terminante d'une cmdlet en erreur terminante que catch pourra attraper. Autres valeurs usuelles : Continue, SilentlyContinue, Ignore, Inquire (liste non relue sur about_CommonParameters).
• $ErrorActionPreference : valeur par défaut pour la session ou le script ; la page about_Try_Catch_Finally note que SilentlyContinue ou Ignore peuvent même supprimer l'effet d'un throw. À manier avec précaution.
• $_ / $PSItem dans catch : objet de type ErrorRecord (propriétés Exception, ScriptStackTrace, ErrorDetails).
• finally : s'exécute à tout coup, y compris après Ctrl+C selon la page ; sert à libérer des ressources.

try {    Get-Content -LiteralPath ./fichier-absent.txt -ErrorAction Stop}catch {    Write-Error "Lecture impossible : $($_.Exception.Message)"}finally {    Write-Verbose "Fin du bloc" -Verbose}

• Contexte : session pwsh, dossier de test où fichier-absent.txt n'existe pas.
• Droits : utilisateur normal.
• Effet : tente de lire un fichier inexistant ; l'erreur est attrapée, un message est écrit sur le flux d'erreurs, puis le bloc finally s'exécute. Aucune modification de fichier.
• Vérification : le message « Lecture impossible : … » apparaît, suivi de la ligne verbeuse « Fin du bloc ». Sans -ErrorAction Stop, catch ne se déclenche pas : essayer.
• Retour arrière : sans objet.

10. Fichiers, JSON et CSV

Sur PowerShell 7, l'encodage par défaut des fichiers texte est l'UTF-8 sans BOM d'après la documentation générale du produit (usage courant, non vérifié dans une page lue) : le préciser avec -Encoding utf8 quand on partage un fichier avec Windows PowerShell 5.1, dont le défaut était différent.

$donnees = @(    [pscustomobject]@{ Nom = "alpha"; Taille = 3 },    [pscustomobject]@{ Nom = "beta";  Taille = 12 })$donnees | Export-Csv -LiteralPath ./essai.csv -NoTypeInformationImport-Csv -LiteralPath ./essai.csv | Where-Object { [int]$_.Taille -gt 5 }$donnees | ConvertTo-Json | Set-Content -LiteralPath ./essai.json(Get-Content -Raw -LiteralPath ./essai.json | ConvertFrom-Json).Count

• Contexte : session pwsh, dossier de test jetable ; données synthétiques. -NoTypeInformation n'est plus nécessaire dans PowerShell 7 d'après l'usage courant (non vérifié) ; sans effet nuisible ici.
• Droits : écriture dans le dossier courant.
• Effet : crée (ou écrase) essai.csv et essai.json dans le dossier courant, relit le CSV en filtrant, relit le JSON et compte les éléments. Un CSV relu donne des chaînes de caractères : d'où [int].
• Vérification : Import-Csv renvoie une seule ligne (beta), et le compte JSON vaut 2.
• Retour arrière : supprimer les deux fichiers de test après relecture des noms : Remove-Item -LiteralPath ./essai.csv, ./essai.json -WhatIf, puis sans -WhatIf.

11. -WhatIf, -Confirm et ShouldProcess

Les cmdlets qui modifient le système (Remove-Item, Set-Content, Stop-Process, Move-Item…) acceptent en général -WhatIf (montre ce qui serait fait, sans le faire) et -Confirm (demande validation). Selon la page « Everything you wanted to know about ShouldProcess » : -WhatIf affiche la description de l'action et ne l'exécute pas ; -Confirm pose la question avant chaque opération ; $ConfirmPreference vaut High par défaut et ConfirmImpact vaut Medium par défaut, si bien qu'une fonction n'interroge pas l'utilisateur sauf demande (ConfirmImpact = 'High' ou -Confirm).

Attention, effet notable. Cette commande a un effet notable. Lire le contexte, les droits et l’effet attendu indiqués après le bloc ; ne jamais l’exécuter sur un système réel sans validation, d’abord dans un environnement de test.

Remove-Item -LiteralPath ./essai.csv -WhatIfRemove-Item -LiteralPath ./essai.csv -Confirm

• Contexte : session pwsh, dossier de test où essai.csv existe (chapitre 10). La sortie affichée en -WhatIf ressemble à « What if: Performing the operation "Remove File" on target … » d'après la page citée.
• Droits : suppression dans le dossier de test (droits de l'utilisateur).
• Effet : la première commande n'efface rien et décrit l'opération ; la seconde demande confirmation, et supprime le fichier si on répond Oui (Y).
• Vérification : après la première, Test-Path ./essai.csv renvoie True ; après la seconde en répondant N, aussi True.
• Retour arrière : la suppression ne passe pas par la corbeille et n'est pas annulable : aucune annulation. Garder une copie, ou travailler sur un fichier de test.

Dans vos fonctions, activer ce mécanisme est simple :

function Remove-FichierEssai {    [CmdletBinding(SupportsShouldProcess, ConfirmImpact = 'High')]    param([Parameter(Mandatory)][string]$Chemin)​    if ($PSCmdlet.ShouldProcess($Chemin, 'Supprimer')) {        Remove-Item -LiteralPath $Chemin    }}Remove-FichierEssai -Chemin ./essai.json -WhatIf

• Contexte : session pwsh, dossier de test ; schéma SupportsShouldProcess / $PSCmdlet.ShouldProcess repris de la page « Everything you wanted to know about ShouldProcess » (consultée le 2026-10-17), avec ses précisions : ShouldProcess près du changement, -Force et -Confirm:$false pour automatiser.
• Droits : écriture dans le dossier de test pour la suppression ; aucune avec -WhatIf.
• Effet : déclare la fonction ; avec -WhatIf, affiche « Supprimer » sur la cible sans rien supprimer. Sans -WhatIf, l'impact High provoquerait une demande de confirmation avant Remove-Item.
• Vérification : essai.json existe toujours après l'appel avec -WhatIf.
• Retour arrière : avec -WhatIf, sans objet. Pour une vraie suppression : aucun retour arrière (pas de corbeille).

12. Politique d'exécution : ce qu'elle est et n'est pas

D'après la page about_Execution_Policies (version 7.6, mise à jour le 2026-08-31) :

• la politique d'exécution est « une fonction de sécurité » qui contrôle les conditions de chargement des fichiers de configuration et d'exécution des scripts, mais elle n'est pas une frontière de sécurité : c'est une « défense en profondeur » ; la page donne l'exemple d'un utilisateur qui la contourne en tapant le contenu du script en ligne de commande ;
• l'application n'a lieu que sous Windows ; sur les systèmes non Windows, la politique par défaut est Unrestricted et ne peut pas être changée : Get-ExecutionPolicy renvoie Unrestricted, le comportement correspond à Bypass, Set-ExecutionPolicy existe mais affiche un message indiquant que ce n'est pas pris en charge ;
• sous Windows, les valeurs sont AllSigned, Bypass, Default, RemoteSigned (défaut des Windows Server et poste client Windows en 7.x), Restricted, Undefined, Unrestricted, avec des portées (Process, CurrentUser, LocalMachine, stratégies de groupe).

Get-ExecutionPolicyGet-ExecutionPolicy -List

• Contexte : session pwsh sur macOS ; sortie attendue d'après la page : Unrestricted.
• Droits : utilisateur normal.
• Effet : lecture de la politique effective. Aucune modification.
• Vérification : la valeur affichée correspond à la documentation ; si elle diffère, noter la valeur et la version de pwsh.
• Retour arrière : sans objet.

13. Modules et PowerShell Gallery : risques de chaîne d'approvisionnement

Un module regroupe des cmdlets et des fonctions. La PowerShell Gallery est, d'après Microsoft Learn, le dépôt central des modules, scripts et ressources DSC ; certains paquets sont écrits par Microsoft, d'autres par la communauté. Le module PowerShellGet (et son successeur PSResourceGet : non vérifié dans les pages lues) installe, met à jour et publie ces paquets.

Un module installé s'exécute avec vos droits : il peut lire vos fichiers, vos variables d'environnement, vos jetons. Installer un module, c'est exécuter le code de son auteur.

• usurpation de nom (typosquatting), compte d'auteur compromis, mise à jour malveillante d'un module légitime ;
• dépendances transitives : un module en installe d'autres ;
• un script « d'installation » qui s'exécute à l'import.

Précautions (bonnes pratiques générales, non vérifiées dans une page officielle consultée) :

1. préférer les modules Microsoft ou d'éditeurs connus ; regarder le nombre de téléchargements, la date, l'auteur, le dépôt source ;
2. lire la page du module sur la Gallery avant de l'installer ; chercher le dépôt public et le lire ;
3. installer pour l'utilisateur courant (-Scope CurrentUser), jamais avec sudo sans nécessité ;
4. épingler une version précise (-RequiredVersion) et noter laquelle ;
5. tester d'abord dans une machine ou un compte jetable ;
6. ne pas ajouter de dépôt tiers ni passer à « Trusted » sans raison.

Get-Module -ListAvailableFind-Module -Name PSScriptAnalyzer -Repository PSGallery

• Contexte : session pwsh, accès à Internet pour la seconde commande ; Find-Module appartient à PowerShellGet (non vérifié, la commande équivalente de PSResourceGet est Find-PSResource). Le nom PSScriptAnalyzer est donné à titre d'exemple d'outil de lint : son adéquation est non vérifiée.
• Droits : utilisateur normal ; aucune installation.
• Effet : la première liste les modules déjà présents sur le poste ; la seconde interroge la Gallery et affiche des métadonnées (version, auteur, description). Aucune modification locale ; la seconde commande envoie une requête réseau.
• Vérification : lire l'auteur et la version proposés ; comparer avec la page du paquet.
• Retour arrière : sans objet.

14. Scripts sûrs

Un script PowerShell sûr, c'est surtout de la discipline :

• Commencer en lecture seule : Get-*, Test-*, -WhatIf. Puis seulement passer à l'écriture.
• Paramétrer plutôt que coder en dur : param() typé, validé (chapitre 8).
• Set-StrictMode -Version Latest et $ErrorActionPreference = 'Stop' en tête de script pour échouer tôt (usage courant, non vérifié).
• SupportsShouldProcess pour toute fonction qui modifie quelque chose (chapitre 11).
• -LiteralPath plutôt que -Path quand le chemin vient d'un utilisateur.
• Pas de construction de commande par concaténation de texte, et jamais Invoke-Expression (iex) sur une donnée externe. Invoke-Expression exécute une chaîne comme du code : même risque que eval en shell.
• Jamais Invoke-WebRequest … | Invoke-Expression ou iwr … | iex : exécuter du code téléchargé sans l'avoir lu.
• Les commandes natives (git, ls…) se lancent avec leurs arguments séparés, sans passer par une chaîne construite.
• Les données externes (JSON reçu, fichier CSV, contenu web) sont de la donnée, jamais du code.
• Écrire les journaux sans jetons ni mots de passe ; pas de Write-Host d'un secret.

Attention, effet notable. Cette commande a un effet notable. Lire le contexte, les droits et l’effet attendu indiqués après le bloc ; ne jamais l’exécuter sur un système réel sans validation, d’abord dans un environnement de test.

Get-Content -Raw ./script-telecharge.ps1Invoke-Expression (Get-Content -Raw ./script-telecharge.ps1)

• Contexte : exemple de ce qu'il ne faut pas faire avec un script non relu ; la deuxième ligne est donnée pour être reconnue et refusée. Ne pas la lancer sur un script dont on ne connaît pas l'auteur.
• Droits : ceux de l'utilisateur : le script aurait accès à tout ce que vous pouvez lire et écrire.
• Effet : la première ligne affiche le contenu (lecture seule : à faire d'abord) ; la seconde exécute ce contenu comme du code.
• Vérification : relire ligne à ligne la première sortie ; chercher les appels réseau, les suppressions, les écritures hors dossier, l'encodage obscurci (Base64).
• Retour arrière : aucun si le script a agi (fichiers supprimés, envoyés). D'où la règle : lire, puis exécuter un script de confiance depuis un fichier (pwsh -File ./script.ps1), jamais via iex.

15. Secrets : SecretManagement, SecureString et leurs limites

• Ne jamais écrire un mot de passe ou un jeton dans un script, un historique, un journal ou une URL. Les passer par une variable d'environnement, par un paramètre [securestring] ou [pscredential], ou par un coffre.
• SecureString : type de chaîne chiffrée en mémoire sous Windows (DPAPI). La documentation générale de .NET déconseille aujourd'hui SecureString pour les nouveaux développements, et sur macOS et Linux elle n'offre pas de chiffrement en mémoire équivalent : cette affirmation vient de connaissances générales et est non vérifiée ici, car la page de référence n'a pas été relue. Considérer SecureString comme une protection limitée, pas comme un coffre.
• Get-Credential demande un identifiant et un mot de passe à l'écran (interactif) : objet PSCredential. Convertir un mot de passe en clair avec ConvertTo-SecureString -AsPlainText -Force écrit le secret en clair dans la commande : à éviter.
• SecretManagement et SecretStore (modules Microsoft.PowerShell) : d'après la page d'aperçu (mise à jour le 2026-06-22), SecretManagement est une couche d'abstraction (Get-Secret, Set-Secret, Register-SecretVault) ; SecretStore est un coffre local qui chiffre un fichier pour l'utilisateur courant avec les API cryptographiques de .NET. La page indique que ces modules sont considérés comme « feature complete », qu'ils ne seront plus activement développés (corrections de sécurité et bugs critiques seulement), que le dépôt est archivé, et que les versions publiées sont SecretManagement 1.1.2 et SecretStore 1.0.6. Elle invite à évaluer chaque extension de coffre non écrite par Microsoft.
• Sur le Mac de Stéphane, le Trousseau macOS est déjà le coffre de l'Orchestrator (bin/secret get NOM, bin/avec-secrets) : un script PowerShell peut recevoir un secret par variable d'environnement le temps d'une commande plutôt que de le lire en clair. Une extension de coffre « KeyChain » est citée sur la page, mais elle est communautaire : non évaluée ici.

Get-SecretVaultGet-Command -Module Microsoft.PowerShell.SecretManagement

• Contexte : session pwsh ; lecture seule. Ces commandes ne fonctionnent que si le module SecretManagement est déjà installé ; sinon Get-Command ne renvoie rien. Le module n'est pas installé par ce cours.
• Droits : utilisateur normal.
• Effet : liste les coffres enregistrés et les commandes du module. Aucune modification. Aucune valeur de secret n'est affichée.
• Vérification : sans module, les commandes signalent une erreur « non reconnue » (comportement attendu, non un problème).
• Retour arrière : sans objet.

16. Lecture seule d'abord : synthèse

Procédure à suivre pour toute nouvelle tâche :

1. Décrire : Get-Command, Get-Help, Get-Member.
2. Lire : Get-*, Test-*, Measure-*. Regarder l'objet entier.
3. Filtrer à l'écran : Where-Object / Select-Object, sans écrire.
4. Essai à blanc : même commande avec -WhatIf.
5. Exécuter sur des données de test, dans un dossier jetable.
6. Vérifier : relire le résultat (Get-ChildItem, Test-Path) et le code de sortie ($?, $LASTEXITCODE : usage courant, non vérifié).
7. Seulement alors, appliquer à des données réelles, avec une sauvegarde.

Exercices et vérifications de fin de cours

Tous dans un dossier de test jetable, aux noms synthétiques.

1. Version. Lancer pwsh, relever $PSVersionTable.PSVersion et la comparer à la page des versions.
2. Découverte. Avec Get-Command, trouver trois cmdlets dont le nom contient Content ; lire l'aide de l'une d'elles.
3. Objet. Exécuter Get-Item . et Get-Member ; lister cinq propriétés.
4. Pipeline. Reproduire le chapitre 5 : fichiers de plus d'1 Ko triés par taille.
5. Format. Afficher le même résultat en Format-Table et Format-List, puis expliquer pourquoi Format-* va en dernier.
6. Structures. Créer une table de hachage et un tableau, ajouter un élément, relire la taille.
7. Fonction. Écrire Get-FichierVolumineux (chapitre 8) ; provoquer les deux refus de validation.
8. Erreur. Reproduire l'exemple du chapitre 9 avec et sans -ErrorAction Stop.
9. CSV et JSON. Exporter deux objets synthétiques, les relire, les filtrer.
10. WhatIf. Lancer Remove-Item … -WhatIf sur un fichier de test, puis le supprimer vraiment après relecture du nom.
11. ShouldProcess. Ajouter SupportsShouldProcess à une fonction qui écrit un fichier de test.
12. Politique d'exécution. Lire Get-ExecutionPolicy -List et expliquer, en deux phrases, pourquoi ce n'est pas une frontière de sécurité.
13. Modules. Choisir un module de la Gallery et remplir la liste de contrôle du chapitre 13 sans l'installer.
14. Données non fiables. Citer trois constructions interdites avec une donnée externe et leur remplaçant.

Critères de réussite

• Distinguer pwsh (7.x) de powershell.exe (5.1, Windows) et citer deux différences.
• Expliquer en quoi un tube d'objets diffère d'un tube de texte.
• Écrire un Where-Object, un Select-Object et un Sort-Object enchaînés.
• Placer Format-* en dernier et exporter avant de formater.
• Déclarer une fonction avec [CmdletBinding()] et une validation.
• Attraper une erreur avec -ErrorAction Stop et try/catch/finally.
• Utiliser -WhatIf avant toute commande à effet.
• Dire que la politique d'exécution n'est pas une frontière de sécurité et qu'elle n'est pas appliquée sur macOS.
• Nommer les risques d'un module de la Gallery et trois précautions.
• Expliquer pourquoi un secret n'est pas écrit en clair, et citer une limite de SecureString.
• Citer le périmètre des sources (documentation 7.6 en ligne, 17 octobre 2026) sans le confondre avec la version installée.