Rencontre 2 - Objets et pipeline
- 👨🏫 Déroulement du cours
- 💻 Exercices à compléter
- 📚 Ressources à consulter
- Rappel du cours précédent
- Correction des exercices
- Exemples de commandes utiles
- Objets
- Pipeline
- Variables
Les exercices suivants se trouvent dans votre section personnelle du bloc-notes du cours, sous l'onglet Exercices:
- Exercice 02: Objets et pipeline
La présentation PowerPoint est sur le Teams du cours, sous le canal Général > Fichiers > Supports de cours.
PowerShell est un langage orienté objet reposant sur le cadre logiciel .NET Framework. De ce fait, chaque commande (cmdlet) retourne un ou plusieurs objets. Cette particularité diffère des commandes externes et des autres langages de shell, qui retournent du texte
Les objets sont beaucoup plus facile à interpréter par des algorithmes, car on peut extraire l'information qu'on souhaite sans procéder à des manipulations de chaînes de caractères. Ils nous donnent l'opportunité de les manipuler à notre guise, en les passant d'une commande à l'autre dans ce qu'on appelle le pipeline. Or, les humains ont plus de facilité à lire du texte que des objets. Donc à la fin de la chaîne de commandes, l'objet résultant est automatiquement converti en texte afin d'être lu par l'utilisateur.
Cette séance de cours porte principalement sur l'utilisation des objets qui résultent des différentes commandes PowerShell ainsi que le chaînage de plusieurs commandes dans le pipeline.
Objets
Les commandes PowerShell retournent un ou plusieurs objets. Un objet est une structure de données, un élément logique d'information d'une structure définie par une classe (ou type). Il est composé de plusieurs membres, soit des propriétés (ou méthodes), qui représentent de l'information décrivant l'objet, et des méthodes (ou fonctions) qui posent une action sur cet objet.
Connaître les membres d'un objet
La commande Get-Member permet d'obtenir la liste des propriétés et des méthodes offertes par cet objet. Dans le cas d'une collection d'objets, elle analyse le type d'objet dans la collection.
On peut spécifier le type de membre pour une recherche plus ciblée.
Obtenir une propriété
Par exemple, la commande Get-Item retourne l'information sur un fichier ou un dossier. Le résultat de cette commande est un objet qui décrit le fichier ou le dossier correspondant.
Si l'objet représente un fichier, il possèdera une propriété .Length qui représente sa taille, en octets. Pour accéder à un membre d'un objet, on utilise le caractère point. Il y a plusieurs manières d'identifier l'objet, soit avec des parenthèses, soit en le passant dans une variable.
Explorer les propriétés d'un objet
Pour explorer un objet, il est également utile de demander à lister toutes ses propriétés.
Il est ainsi plus facile de trouver des propriétés intéressantes.
Appeler une méthode
L'appel d'une méthode se fait de la même manière que pour une propriété, sauf que la méthode peut accepter des paramètres. Comme une méthode n'est pas une commande PowerShell, les paramètres n'obéissent pas aux même règles: ils ne sont pas nommés, et doivent être spécifiés en parenthèses.
Si la méthode qu'on appelle n'a pas de paramètre, il faut écrire les parenthèses quand même.
Connaître le type d'un objet
Une manière de connaître le type d'un objet est d'appeler sa méthode GetType(). Cette méthode existe dans tous les types d'objets, et retourne un objet qui décrit le type de cet objet.
Par exemple, la commande Get-Item peut retourner des fichiers et des dossiers, qui sont des structures très différentes. Selon l'élément que l'on tente d'obtenir, le type de l'objet résultant sera différent.
Si la commande retourne plusieurs objets, alors le type de l'objet retourné sera un array, c'est-à-dire un objet qui contient plusieurs objets. On les identifie avec des crochets [ ] à la fin de leur type.
Le pipeline
Le pipeline est le mécanisme par lequel l'information circule dans une session PowerShell. Il permet de chaîner des commandes afin que l'objet sortant d'une commande entre dans la prochaine pour y être traité. Le caractère pour chaîner les commande est la barre verticale | (appelée "pipe" ou "tube").
Pour mieux conceptualiser le pipeline, on peut voir chaque commande comme une machine qui prend un ou plusieurs objets en entrée (input), effectue un traitement en tenant compte de ces intrants (qui peuvent impliquer des appels au système d'exploitation), puis produit un objet en sortie (output) et le jette dans le pipeline.
Une commande produisant un objet en sortie (ou un objet déposé directement dans le pipeline) sera donc passé en entrée à la commande suivante, qui le passera dans un de ses paramètres, le traitera et produira un autre objet de type différent, qui pourra être passé à la prochaine commande, et ainsi de suite.
À la fin du pipeline, l'objet qui s'y trouve "tombe" dans la console (le host), où il sera automatiquement converti en texte selon plusieurs règles régies à la fois par la configuration de PowerShell et par la nature de cet objet.
On peut éviter à l'objet de tomber dans la console en le "pipant" dans une autre commande (habituellement, avec le verbe Out-), ou bien en l'affectant à une variable.
Si on souhaite se débarrasser de l'objet résultant, il suffit de terminer la chaîne de pipeline par la commande Out-Null, qui désigne simplement une sortie vers rien du tout.
Sélection
Plusieurs commandes, et particulièrement celles dont le verbe est Get, produisent des objets en sortie dans le pipeline, qui possèdent des propriétés. Certains objets en possèdent un grand nombre, et lorsqu'ils sont affichés sous forme de texte dans la console, parfois seules les propriétés principales sont affichées. Une opération simple consiste à "extraire" de cet objet certaines propriétés. Cette opération se nomme la "sélection" et peut être réalisée avec la commande Select-Object.
La sélection ne "transforme" pas vraiment l'objet, elle en produit plutôt une copie transformée.
On peut créer des objets composés de certaines propriétés en spécifiant le paramètre -Property de la commande Select-Object.
Par exemple, la commande suivante permet de "transformer" l'objet représentant le service "winmgmt" en objet composé uniquement de ses propriétés Nameet Status.
Get-Service -Name "winmgmt" | Select-Object -Property "Name", "Status"
On remarque qu'à l'exécution de cette commande, il reste des entêtes de colonnes. Alternativement, on peut extraire seulement la valeur de la propriété en spécifiant le paramètre -ExpandProperty.
Get-Service -Name "winmgmt" | Select-Object -ExpandProperty "Status"
Commandes de formatage
Lorsqu'un objet arrive au bout du pipeline, il est automatiquement converti en texte par PowerShell afin d'être affiché dans la console dans un format lisible par l'utilisateur. Comme un objet possède des données brutes, PowerShell doit faire un choix dans sa manière de représenter textuellement l'objet à l'écran. Le formatage se fait en fonction de plusieurs facteurs, dont la nature de la commande, le nombre de propriétés de l'objet, etc. On peut utiliser des commandes de formatage (typiquement, des commandes débutant par le verbe Format-.)
| Commande | Alias | Description |
|---|---|---|
Format-List | fl | Convertit l'objet en texte sous forme de liste |
Format-Table | ft | Convertit l’objet en texte sous forme de tableau (moins détaillé) |
Format-Wide | fw | Convertit l’objet en texte réparti sur la largeur (très sommaire) |
Format-Hex | fhx | Convertit des données en texte montrant leur valeur hexadécimale |
On peut également effectuer des sélections à l'intérieur même de la commande de formatage.
C'est pratique pour explorer toutes les propriétés d'un objet. On peut le formater sous forme de liste et forcer l'affichage de toutes ses propriétés avec le symbole *.
Une fois un objet passé dans la commande de formatage, il est automatiquement converti en texte. C'est pourquoi le formatage est généralement utilisé à la toute fin du pipeline, ou avant une commande de sortie (Out-).
Commandes de sortie
Par défaut, lorsqu'un objet arrive au bout du pipeline, il est affiché dans la console (host) après avoir été converti en texte. On peut rediriger l'objet vers une autre sortie, comme un fichier ou une imprimante. Voici quelques commandes de sortie disponibles:
| Commande | Alias | Description |
|---|---|---|
Out-Default | Envoie l’objet vers la sortie par défaut (implicite, par défaut Out-Host) | |
Out-Host | oh | Envoie l’objet vers la console (il sera converti automatiquement en texte) |
Out-File | Envoie l’objet vers un fichier (il sera converti automatiquement en texte) | |
Out-Null | Envoie l’objet vers le néant (l’objet sera détruit) | |
Out-String | oss | Convertit les objets en chaîne de caractères |
Out-Printer | lp | Envoie l’objet vers une imprimante |
Out-GridView | ogv | Sort l’objet vers une grille graphique (dans une fenêtre séparée) |
Paramètre PassThru
Ce ne sont pas toutes les commandes qui produisent un objet sur le pipeline. Certaines commandes n'en produisent pas, soit parce qu'elles n'ont pas à le faire, soit parce que la plupart du temps, on n'a pas besoin de cet objet.
Par exemple, la commande Start-Process sert à démarrer un processus (un exécutable). Par défaut, lorsqu'on lance cette commande, elle se contente de demander à Windows de créer un processus et ne retourne rien.
Mais il peut arriver qu'on souhaite enregistrer des informations sur le processus nouvellement créé. Certaines commandes offrent un paramètre -PassThru, qui permettent de forcer la production d'un objet décrivant le résultat de la commande. Dans ce cas, la commande Start-Process produit un objet décrivant le processus.
Commande Tee-Object
La commande Tee-Object sert à enregistrer un objet dans une variable ou un fichier, en le relayant en même temps sur le pipeline.
Les variables
Les variables en PowerShell sont identifiées avec le préfixe $. Par exemple, la variable Foo s'écrit $Foo dans le code PowerShell. Le nom de la variable est Foo, et le caractère $ indique à PowerShell qu'il s'agit d'une variable.
Une variable contient un objet. L'opération consistant à mettre un objet dans une variable se nomme une affectation, et on la réalise à l'aide de l'opérateur d'affectation, =. Cet opérateur récupère l'objet résultant à la fin du pipeline afin de le stocker dans la variable, plutôt que de le laisser tomber dans la console.
Pour obtenir le contenu d'une variable, on utilise simplement son nom avec le caractère $. Cela a pour effet d'envoyer son contenu dans le pipeline. On peut aussi utiliser cette variable pour passer un objet dans un paramètre.
Une variable contient un objet, donc on peut l'utiliser pour accéder à toutes les méthodes et tous les attributs offerts par cet objet.
On peut connaître la liste de toutes les variables déclarées avec la commande Get-Variable.
Variables prédéfinies
Certaines variables sont prédéfinies par PowerShell.
| Variable | Description |
|---|---|
$true | Représente la valeur booléenne vraie |
$false | Représente la valeur booléenne fausse |
$null | Représente la valeur nulle |
$PID | Le numéro d'identification du processus courant |
$PWD | Représente le répertoire courant |
$args | Contient un tableau des arguments passés à l'appel d'une fonction ou d'un script |
$error | Liste des erreurs lors de la session |
$PSVersionTable | Tableau des versions de PowerShell |
$Host | Objet qui permet de modifier l'interface PowerShell |
$Home | Le chemin du répertoire de l'utilisateur (typiquement C:\Users\nomdutilisateur) |
$PSHome | Le chemin dans lequel PowerShell est installé |
$PSCulture | La culture de la session PowerShell (fr-CA, en-US, etc.) |
$_ ou $PSItem | Valeur courante dans le pipeline |
| ... |
Variables d'environnement
Le système d'exploitation offre à tous les processus un ensemble de variables gérées par le système et qui procurent de l'information sur l'environnement d'exécution.
Voici quelques variables d'environnement (mais il y en a plusieurs autres).
| Variable (PoSH) | Description |
|---|---|
$env:COMPUTERNAME | Le nom d'hôte de l'ordinateur |
$env:USERNAME | Le nom de l'utilisateur |
$env:USERDOMAIN | Le nom du domaine de l'utilisateur courant (format NetBIOS) |
$env:USERDNSDOMAIN | Le nom du domaine de l'utilisateur courant (format FQDN) |
$env:LOGONSERVER | Le nom du contrôleur de domaine ayant authentifié l'utilisateur lors de son logon |
$env:UserProfile | Le chemin vers le profil de l'utilisateur (typiquement C:\Users\nomdutilisateur) |
$env:APPDATA | Chemin vers le répertoire AppData/Roaming de l'utilisateur courant |
$env:LocalAppData | Chemin vers le répertoire AppData/Local de l'utilisateur courant |
$env:HOMEDRIVE | Le lecteur sur lequel est situé le profil de l'utilisateur |
$env:HOMEPATH | Le chemin relatif du profil utilisateur sur le lecteur HOMEDRIVE |
$env:TEMP | Le chemin vers le répertoire temporaire de l'utilisateur (même que TMP) |
$env:TMP | Le chemin vers le répertoire temporaire de l'utilisateur (même que TEMP) |
$env:ALLUSERSPROFILE | Le chemin vers le profil utilisateur commun à tous les utilisateurs (programdata) |
$env:ProgramData | Le chemin du répertoire qui contiennent les configurations du système |
$env:ProgramFiles | Le chemin vers le répertoire contenant les fichiers de programme |
$env:{ProgramFiles (x86)} | Le chemin vers le répertoire des fichiers de programme 32-bits (WoW64) |
$env:Path | La liste des chemins qui contiennent des commandes exécutables |
$env:PATHEXT | La liste des extensions à considérer comme exécutables |
$env:PUBLIC | Le chemin vers le répertoire public (partagé par tous les profils) |
$env:NUMBER_OF_PROCESSORS | Le nombre de processeurs logiques installés dans le système |
$env:PROCESSOR_ARCHITECTURE | L'architecture du processeur (x86, amd64, ia64, arm64, etc.) |
$env:ComSpec | Le chemin vers l'interpréteur de commande par défaut |
$env:OneDrive | Le chemin vers le répertoire de synchronisation de OneDrive |
$env:OneDriveCommercial | Le chemin vers le répertoire de synchronisation de OneDrive For Business |
$env:SystemDrive | Le lecteur sur lequel Windows est installé (typiquement C:) |
$env:SystemRoot | Le chemin vers le répertoire où Windows est installé (typiquement C:\Windows) |
$env:PSModulePath | La liste des chemins qui contiennent des modules PowerShell |
Dans l'interpréteur de commande classique (cmd), et à plusieurs autres endroits du système (comme dans le shell graphique, le registre, etc.), les variables d'environnement sont accessibles en les entourant de deux symboles %.
La commande Set permet d'obtenir la liste des variables d'environnement.
Sous PowerShell, la syntaxe est différente. On utilise le préfixe $env: pour y accéder.
Pour obtenir la liste, on fait un Get-ChildItem sur le lecteur env:, qui contient toutes les variables d'environnement du processus.
Les variables d'environnement sont rattachées à un processus particulier, et chaque processus créé hérite des variables d'environnement du processus parent. Ainsi, si on fait des modification à une variable d'environnement, celle-ci ne sera modifiée que dans ce processus et pas les autres. De plus, le changement sera détruit après la fin du processus, lorsque la fenêtre PowerShell est fermée. Il est possible de modifier une variable d'environnement de manière permanente, mais nous verrons cela dans une séance ultérieure.
Transcription
Il est possible de demander à PowerShell d'enregistrer automatiquement dans un fichier tout ce qui se fait dans la fenêtre. C'est pratique pour garder des traces de ce qu'on fait. La commande pour tirer profit de cette fonctionnalité est Start-Transcript. On fournit à la commande le chemin vers un fichier, et tout ce qui est écrit et affiché dans la console y est sauvegardé. Pour terminer l'enregistrement, il suffit de lancer Stop-Transcript, ou simplement de mettre fin à la session PowerShell.
