Utiliser Microsoft Windows PowerShell

Windows PowerShell est un environnement de ligne de commande Windows conçu pour les administrateurs système. Il comprend une invite de commande (shell) interactive et un environnement de script (pouvant être utilisés indépendamment l'un de l'autre ou ensemble), offrant une manière de traiter des tâches orientées commande.

La philosophie de Windows PowerShell s’appuie sur deux principes :
1 - Les commandes ne sont pas basées sur du texte mais sur des objets (.NET en l'occurrence).
2 - Les commandes sont extensibles.

L’objectif des concepteurs de PowerSell a été d’obtenir quelques chose d’aussi interactif, de programmable et composable que le shell UNIX, d’orienté objet, bénéficiant de la structure du framework Dot NET 2.0, et puis pouvoir accéder aussi facilement aux fournisseurs du système, accéder à un annuaire, un registre, etc… que la simplicité que l’on a lorsqu’on accède au système de fichier et à la lecture de fichiers contenus dans un répertoire.

Que peut-on faire avec PowerShell ?

Le point principal d’intérêt de Windows PowerShell est qu’il permet de résoudre des problématiques d’administration par le Scripting. Par exemple quand on a à gérer un grand parc de machines, quand on veut faire une opération sur une machine en général c’est très simple, mais quand on a à répliquer n fois la même opération sur 10 ou 50 ou 1000 machines ça devient très compliqué, encore plus quand ce n’est pas intégré dans l’interface graphique. Avec un outil de Scripting une fois que l’on possède la commande qui fonctionne sur une machine on peut réaliser une boucle sur le nombre de postes sur lesquels on veut répliquer l’opération.

L’autre point que peut résoudre PowerShell c’est la possibilité de concevoir de petits outils d’administration dédiés à certaines tâches spécifiques. Par exemple PowerShell permet de créer un outil pour créer des utilisateurs avec un certain nombre de limitations, sans ouvrir toute la richesse fonctionnelle, sans développer une interface en Visual Studio, pouvant nécessiter une grande connaissance de programmation et user d’un niveau de complexité très poussé.

Quelle configuration est requise pour pouvoir utiliser PowerShell ?

Windows PowerShell est disponible actuellement en version 1.0

Le pré-requis est le Framework.Net 2.0

Windows PowerShell est disponible pour :

Windows Server
Code Name
Longhorn

Une « feature » à installer
Pas installée par défaut
Pas disponible avec « Server Core »

.x86

.X64
.IA64

Windows Server
2003 SP1

Une mise à jour système entre le SP1 et le SP2 (KB926139, 140, 141)
A télécharger

.x86

.X64
.IA64

Windows Vista

Une mise à jour (KB928439)
A télécharger

.x86

.X64

Windows XP SP2

Une mise à jour système (KB926139, 140, 141)
A télécharger

.x86

.X64

Pour Windows Server et Windows XP nous avons 3 versions liées aux problématiques de langage :

- Nous avons une version totalement anglaise (KB926139) ;

- Une version localisée (KB926140 : comprenant 10 langues : Chinois simplifié, Chinois traditionnel, Français, Allemand, Italien, Japonais, Coréen, Portugais (Brésilien), Russe et Epagnol) ;

- Une version pour les systèmes MUI (KB926141).

A savoir pour ne pas être surpris : Sous Windows Server 2003, PowerShell est vu comme une mise à jour du système qui s’applique après le Service Pack 1 mais avant le Service Pack 2. Donc si on a appliqué avant le Service Pack 2 on ne peut pas installer PowerShell. Si on installe PowerShell après avoir appliqué le SP2, Windows Server 2003 renverra un message d’erreur. Donc il faut d’abord désinstaller le SP2, installer PowerShell, et ensuite installer le SP2.

Microsoft signale que le problème sera résolu prochainement car sur Windows Server nom de code Longhorn, Windows PowerShell n’est plus un add-on mais il est intégré complètement dans le système sous forme de « feature » à activer, car n’étant pas activé par défaut.

Quelles sont les caractéristiques de Windows PowerShell ?

Les concepteurs de Windows PowerShell ont joué au maximum la carte de l’homogénéité et de la Cohérence.

La syntaxe a été alignée sur C#. On peut donc facilement convertir du code C# en PS et réciproquement.

La caractéristique principale, dans PowerShell Tout est Objet !

Les bases de PowerShell avec Get-Command

Le modèle est basé sur la commande (ou Cmdlet) :

< verbe >-< nom >

Le « verbe » définit l’action que l’on va faire (par exemple Get), suivi du tiret « - », suivi du nom ou type d’objet sur lequel on va appliquer l’action en question.

Exemple : Get-Command

La commande Get-Command, est la première commande à retenir. Elle permet de récupérer la liste des commandes et leurs paramètres, comme nous pouvons le voir ci-dessous :

Nous pouvons retenir pour commencer 4 commandes de base récurrentes :

Get-Command Informations de base sur les commandes

Get-Help Aide de base (utiliser –full)

Get-Member Informations sur les objets

Get-PSDrive Informations sur les lecteurs étendus

Ci-dessous un tableau présentant quelques-uns des nombreux paramètres de Windows PowerShell :

-confirm	Boolean	Demande une confirmation à l’utilisateur
-whatif	Boolean	Simule simplement l’exécution de la commande
-verbose	Boolean	Fournit des informations supplémentaires sur l’exécution de la commande
-debug	Boolean	Fournit des informations de débogage
-erroraction	Enum	Contrôle du comportement en cas d’erreur
-errorvariable	String	Nom de la variable où placer les objets en erreur
-outputbuffer	Int32	Contrôle le nombre d’objets à mettre en mémoire tampon
-outvariable	String	Variable où placer les objets en sortie

Il y a 129 « Cmdlet » (prononcer « comandelette ») prédéfinies par défaut dans le système.

La commande Get-Command –verb set

La commande Get-Command –verb set permet de récupérer tout simplement toutes les commandes dont le verbe commande par « set ».

La commande Get-Command set* renvoie tout ce qui commence par « set » en tant que Cmdlet, comme ci-dessus… Mais aussi...

Comme vous pouvez le remarquer, elle renvois d’autres types de commandes,

Comme nous pouvons le constater dans la colonne de gauche « CommandType », « set » est un Alias, qui permet de faire un raccourci pour une commande plus complexe.

« sethc.exe » par exemple est une Application (.exe), donc si on tape la commande dans la fenêtre de PowerShell cela exécutera la commande en question.

La commande Get-Command Set-Alias

Revenons à une commande, la commande Get-Command set-alias. Nous pouvons la formater la présentation de façon plus sympathique.

Tapons la commande comme ceci :

Get-Command set-alias | format-list *

Cette commande permet d’obtenir plus de détails, en particulier la « dll » de PowerShell à laquelle elle correspond, et sa définition complète avec tous les paramètres de la commande.

Comme nous venons de le voir avec « set* », des commandes peuvent être des « .exe », nous pouvons récupérer des informations sur ipconfig en lançant la commande Get-Command ipconfig | format-list *

Comme nous le voyons ci-dessus, la commande ipconfig renvoie à l’application ipconfig.exe qui a pour path (chemin) C:\WINDOWS\system32\

Cette méthode est valable aussi pour récupérer sur le PowerShell que nous utilisons.

Tapons la commande: Get-Command powershell | format-list *

Nous obtenons quelques informations, entre autres la version (FileVersion), et la langue (Language) de l’application qui est exécutée.

La commande Write-Host

Tout Shell possède son fameux « Hello World », et sur PowerShell nous avons la commande suivante qui permet de l’écrire de cette façon :

write-host Hello World

Evidemment PowerShell va plus loin que ce type d’usage, nous allons le voir.

La commande Get-Help

Deuxième commande à retenir, la commande get-help

Cette commande ne se contente pas de fournir la liste des commandes disponibles, elle fournie aussi des informations sur les commandes en question.

Ci-dessus nous obtenons de l’aide sur l’aide, ce qui n’est pas le plus intéressant.

Par contre si nous tapons la commande get-help * nous obtenons de l’aide sur tous les objets qui ont une aide correspondante, nous n’afficherons pas toute la liste affichée sur la capture d’écran suivant...

Dans cette liste nous avons de l’aide pour de nombreuses catégories :

Alias, Cmdlet, Provider, et HelpFile.

Helpfiles correspond aux éléments commençant par « about_ », ce sont des ensembles de fichiers d’aides associés au système.

Ils donnant des informations sur pas un mais plusieurs ensembles de commandes, ici par exemple « about_Flow_Control » qui concerne les boucles.

La commande get-help peut être abrégée par la commande help.

Cette commande abrégée donne le même résultat que nous avons eu sur les précédents écrans, mais nous avons cette fois-ci une vue page par page avec l’invitation « -- Suite -- », en bas à gauche de notre écran PowerShell, qui permet de passer à la page suivante en pressant la barre d’espace du clavier.

Couramment, la commande get-help est à utiliser avec l’extension –full. Si nous faisons un get-help <nom> on a droit seulement à un premier niveau qui ne donne pas toujours des informations pertinentes, alors qu’en tapant get-help <nom> -full nous obtenons de l’aide accompagnée d’exemples associés qui sont en général plus parlant.

Le plus souvent les commandes commençant par get-<nom> ont comme abréviation le <nom> seul car get- est le verbe par défaut que l’on peut appliquer.

La commande Get-Help About

La commande get-help about* nous permet de visualiser toute la liste des fichiers « about_ ».

Ces fichiers comme on a dit plus haut sont des fichiers d’aides (Helpfiles). Nous pouvons en ouvrir un, par exemple get-help about_commonparameters :

C’est le fichier « about_ » des paramètres communs.

Les 129 commandes de PowerShell ont un certain nombre de paramètres ( Parameters ) qui eux aussi sont communs, permettant par exemple de définir le niveau de verbosité ( Verbose ) de la commande, de pouvoir effectuer du débogage ( Debug ), …

Il y a deux paramètres très intéressants, disponibles seulement sur les commandes modifiant le système, et disponibles en bas de cette page d’aide de about_commonparameters : WhatIf et Confirm

WhatIf et Confirm sont deux paramètres que l’on peut ajouter à la fin d’une commande délicate, par exemple une commande pouvant supprimer 10.000 fichiers.

Le paramètre WhatIf ne va pas exécuter la commande mais simuler les fichiers qu’il aurait supprimés si la commande avait été réellement exécutée.

Le paramètre Confirm quand à lui passe à l’étape supérieure, c'est-à-dire qu’il exécute la commande, mais avant d’exécuter la commande, par exemple celle susceptible de supprimer nos 10.000 fichiers, il va demander « Etes-vous bien sûr de vouloir exécuter la suppression ? Oui ou Non ?».

Donc tout cela est décrit dans le fichier « about_ ». Ces fichiers d’aides « about_ » sont situés dans C:\WINDOWS\system32\windowspowershell\v1.0

Tous les fichiers « about_ » sont stockés dans le dossier de langue, dans notre cas le dossier « fr ». Ces fichiers sont au format « .txt » (texte).

Nous poursuivons encore un peu avec la commande Get- .

Si nous tapons la commande Get-Command Get* nous permet d’obtenir toutes les commandes commençant par Get- .

Si nous tapons la commande Get-Date nous obtenons bien entendu la date.

Si nous tapons la commande Date nous obtenons le même résultat.

Mais attention, il y a une exception à cette méthode de commandes abrégées.

Si vous tapez Command, vous n’allez pas obtenir un Get-Command, mais nous obtenons l’ancien Shell Windows Dos :

De ce fait, si nous tapons la commande help, nous sommes dans le cmd.exe classique :

Donc nous devons ressortir du cmd par la commande exit pour nous retrouver dans le Windows PowerShell :

Nous pouvons vérifier notre précédente exécution de lancement d’une application depuis PowerShell en utilisant justement la commande get-command command, cela nous affiche ceci :

C’est bien le command.com depuis le system32 qui a été lancé à partir de la commande Command.

Revenons aux Alias.

Rappelons qu’un alias est un autre nom ou surnom utilisé pour une applet de commande ou un élément de commande, tel qu'une fonction, un script, un fichier ou un fichier exécutable. Il est possible d’utiliser l'alias au lieu du nom d’une commande.

L’un des Alias les plus courant est dir. Tapons cette commande :

Il faut garder à l’esprit que dir n’est pas une commande de PowerShell. La commande dir étant tellement connue et utilisée qu’elle a été intégrée à PowerShell sous la forme d’un Alias.

Tapons maintenant la commande get-command dir :

Nous voyons que la vraie définition de l’Alias dir est Get-ChildItem.

Ce qui veut dire que soit on utilise Get-ChildItem, soit on continue à utiliser dir.

Mais il faut soulever un risque avec l’usage des Alias. Il faut rappeler qu’un Alias peut être à tout moment redéfini, et cela peut-être sources de problèmes dans l’exécution des scripts. Par conséquent il est recommandé d’utiliser tout de même la commande prédéfinie, le Get-ChildItem dans les scripts à la place du dir.

Regardons maintenant la commande get-command help :

On remarque que si on tape help c’est une fonction, par contre si on tape help.exe on fera appel à une application.

A savoir que dans PowerShell il y a une notion de précédence. Si on tape help PowerShell fera passer en priorité la fonction. Par contre si on détruit la définition de fonction PowerShell lancera l’application.

Chose intéressante, nous pouvons récupérer la définition de la fonction.

La get-command récupère un tableau, et si on récupère le premier élément du tableau on a la fonction help.

Tapons la syntaxe suivante (get-command help)[0].definition :

Cela nous donne une idée de code en PowerShell.

Déplaçons-nous sur le dossier temp placé sur le disque du C:\ en tapant :

cd c:\temp

Ensuite tapons notre alias dir pour voir le contenu de notre dossier :

Nous pouvons voir que notre dossier contient un fichier nommé monscript.ps1.

C’est un script PowerShell, identifaible par l’extension.ps1. Un ensemble de commandes PowerShell stockées dans un fichier .ps1, mais ce type de fichier n’est pas exécutable par défaut. Par défaut ce fichier est seulement éditable.

Revenons à nouveau à get-command.

Si nous faisons un get-command de monscript.ps1, il va détecter le script…

Tapons la commande get-command ./monscript

PowerShell nous indique que c’est un scripte externe, et qu’il est stocké dans c:\temp.

A retenir pour conclure cette partie, nous avons 5 catégories de commandes :

Alias

Alias pour une commande

Dir

Function

Une suite de commandes existant en mémoire uniquement le temps d’une session PowerShell (parsée une seule fois)

Help

Cmdlet

Commande prédéfinies

Get-command

Get-process

Script

Une suite de commandes existant dans un fichier et chargé en mémoire pour l’exécution (parsée à chaque fois)

./monscript.ps1

Application

Fichier exécutable se trouvant dans le PATH

Notepad

La manipulation d’objets

Comme nous l’avons dit en première partie, « tout est objet » dans PowerShell.

Nous allons voir ce qui est manipulable à partir de PowerShell.

Les expressions

Nous pouvons manipuler des nombres et des expressions dans PowerShell.

Tapons 22 * 4 dans PowerShell

Nous obtenons le résultat de cette opération toute simple.

PowerShell permet d’utiliser des constantes, par exemple Kb, Mb et Gb sont reconnues comme respectivement Kilobites, Mégabites et Gigabites, cela peut être utile dans des scripts.

Nous pouvons manipuler des chaines de caractères, par exemple :

Tapons : "Le petit chat" + " est dans" + " l’arbre"

Nous pouvons aussi manipuler des entiers, des flottants et des chaines de caractères ensemble. Tapons par exemple : 8 + 5.2 + "36"

Nous voyons dans cette expression que la chaine de caractères « 36 » a été convertie en valeur numérique et additionnée à l’entier et au flottant.

Les variables

PowerShell permet de manipuler des variables.

Tapons :

$a="PowerShell est génial"

$a.length

Dans la variable a nous avons mis une chaine de caractères et nous avons récupéré sa longueur par length.

Ensuite nous pouvons tout mélanger, c'est-à-dire des expressions et des commandes. Par exemple tapons: $a.length *2

Nous venons de multiplier la longueur par 2.

Nous lançons une opération un peu plus complexe :

Le résultat est …

Par contre si nous tapons : write-host (date).day + 5

Le résultat n’est pas le même …

Comme nous pouvons le comprendre, la différence des résultats s’explique au niveau des positions des parenthèses :

· Dans la première ligne nous évaluons toute l’expression sous forme numérique. En effet nous sommes le 12 décembre 2008, et si nous additionnons 12+5 nous obtenons bien 17.

· Dans la seconde ligne les parenthèses n’englobent pas l’expression, nous restons avec une chaine de caractères, ce qui nous donne 14 + 5.

Grâce à cet exemple nous voyons bien que nous pouvons maitriser le niveau d’évaluation sur les expressions.

Autre exemple de calcul…

Dans la partie précédente de ce tutoriel, nous avons vu les commandes avec get-command.

Si nous tapons (get-command).count

Nous obtenons…

Nous avons bien la confirmation qu’il y a bien 129 commandes prédéfinies dans PowerShell.

Retournons sur path C:\ en tapant cd c:\

Nous tapons maintenant (get-command *.exe).count * 10

Nous obtenons le nombre de commandes exécutables accessibles dans le path courant, et ce total est multiplié par 10 pour notre exemple.

Ce qui veut dire que nous avons 410 commandes exécutables disponibles.

Les types d’objets

Nous avons tapé plus haut une variable à une chaine de caractères de type :

$a="PowerShell est génial"

Si nous tapons :

$a.gettype()

Nous venons de récupérer le type de l’objet, du type « String » au sens Dot Net.

Nous pouvons à nouveau manipuler l’expression que nous avons vu plus haut, comportant un entier, un flottant et une chaine de caractères.

Tapons cette fois-ci : (8 + 5.2 + "36").gettype()

PowerShell converti dans le type numérique le plus grand pour englober l’ensemble des chiffres disponibles.

Nous pouvons forcer les types :

Tapons :

$a = [int] " 4 "

Et ensuite tapons :

$a.gettype()

Dans la variable « a » nous mettons une chaine de caractères « 4 » et on la force à être de type « integer », forçant la conversion comme nous l’avons eu dans l’expression précédente.

Autre exemple avec une chaine de caractères que nous forçons à être du type date.

Tapons :

$d = [datetime]"2008-03-19"

Et ensuite tapons :

$d.gettype()

Nous avons demandé à PowerShell de convertir tout simplement la variable « d » contenant la chaine de caractères « 2008-03-19 » en type « date ».

Nous voyons bien ci-dessus sur la capture que PowerShell a bien récupéré la chaine de caractères de la variable « d » et qu’il l’a transformé en un objet de type « DateTime ».

Maintenant ajoutons 100 jours à notre date.

Tapons :

$d.adddays(100)

PowerShell nous effectue le calcul en ajoutant 100 jours à la variable « d ».

La commande Get-Member

Notre 3me fonction à retenir est Get-Member.

Nous avons « $d » qui est une variable de type date définie plus haut :

Tapons

$d | get-member

Get-Member permet d’obtenir toutes les propriétés, les méthodes accessibles sur un objet. Ici nous avons une variable de type « date », par conséquent nous obtenons la liste des fonctions prédéfinies de type « date ». Lors de conception d’un script il suffit de chercher la bonne fonction prédéfinie qui va bien avec notre objet.

Tapons :

$d | get-member -membertype property

Souvenez-vous de Get-ChildItem. Nous l’avions vu avec son Alias Dir.

Nous pouvons aussi effectuer un Get-Member à Get-ChildItem.

Tapez :

Get-Childitem | get-member

La liste fait plusieurs écrans, la capture écran est bien raccourcie.

Nous obtenons sur l’expression Get-Childitem | get-member toutes les opérations disponibles sur les fichiers, par exemple la dernière date de mise à jour…etc…

Faisons la même chose sur du numérique.

Tapez :

1 | get-member -membertype method

Nous avons beaucoup moins de fonctions standard prédéfinies sur les numériques.

Pour toutes manipulations de nombres en PowerShell il faut accéder à la librairie mathématique. Soit on exécute les 4 opérations classiques, dans ce cas elles sont intégrées à PowerShell, par contre pour toutes les opérations plus poussées (logarithmes, cosinus), on y a accès via la librairie mathématique du framework Dot Net.

Manipuler du XML avec PowerShell

PowerShell est capable de manipuler du langage XML, type prédéfini par défaut.

Il suffit de signaler la variable XML en la mettant entre crochets en début du code.

Tapons le code suivant :

$l = [xml]( "<livre code='1-506043-45-10'> <titre>Jurassic Parc</titre> <prix>19.95 </prix> </livre>")

Tapons : $l

Rien de phénoménal jusque là…

Tapons maintenant : $l.livre

Là par contre nous avons d’affiché les différents champs XML.

Et si nous voulons récupérer un champ précis, prenons le prix, il suffit de taper : $l.livre.prix

Nous arrêterons là notre exemple avec XML, les possibilités étant nombreuses il faudrait beaucoup plus de temps pour aborder le sujet XML/PowerShell en profondeur.

Manipuler des tableaux avec PowerShell

PowerShell permet de créer des tableaux simplement avec des virgules.

Tapons :

$t=1,2,3

$t.gettype()

Le résultat affiché nous indique bien que nous récupérons bien un Array, c'est-à-dire un tableau « Object [] », d’objets.

Nous avons donc un tableau « t » initialisé avec 3 valeurs (1,2,3).

Attention ici « 1,2 » c’est un tableau à deux éléments, ce n’est donc pas un « 1.2 », cela ne veut pas dire la même chose.

Nous allons affecter notre tableau « t » dans « u ».

Tapons :

$u = $t

Et tapons :

Nous obtenons bien notre tableau dans « u ».

A savoir, les tableaux sont indexés à partir de 0.

Nous allons justement modifier le premier élément de notre tableau. Tapons :

$t[0] = "abc"

Et regardons maintenant le contenu de notre tableau « t », en tapant : $t

Nous avons bien notre premier élément qui a été modifié.

Il est tout à fait possible de mixer des chaines de caractères et des entiers, car comme vous le savez déjà, tout est objet, et nous manipulons ici des objets dans notre tableau.

Le « u » a été affecté un peu plus haut, et a été modifié aussi :

Dans « $u» nous avons un pointeur vers « $t ».

Nous avons donc une affectation par valeurs.

L’opérateur « + » entre deux tableaux permet de concaténer.

Tapons :

$v = $t + $u

Et tapons :

Nous avons donc un tableau de 6 valeurs.

Nous pouvons forcer aussi un tableau à contenir que des entiers.

Tapons :

$t = [int[]](1,2,3)

Demandons-lui maintenant d’insérer une chaine de caractères dans notre tableau.

Tapons :

$t[0] = "abc"

Nous avons un message de refus car il ne peut pas convertir « abc » en entiers.

Il est possible aussi d’utiliser la multiplication sur les tableaux.

Tapons :

$t = $t* 3

Notre tableau « $t » est 3 fois le tableau « $t » initial, les éléments sont dupliqués.

Et nous pouvons voir la longueur de notre tableau.

$t.length

Les tableaux associatifs avec PowerShell

Par défaut nous allons créer un tableau vide sous PowerShell en tapant :

$h = @{}

Ensuite nous allons indexer notre tableau, non pas par un indice numérique mais une chaine de caractères. Nous allons donner une correspondance entre les dieux grecs et romains. Par exemple ici, « Hermes » correspond au dieu « Mercure ».

Tapons :

$h["Hermes"]= "Mercure"

$h["Zeus"]= "Jupiter"

$h["Posseidon"]= "Neptune"

$h["Hades"]= "Pluton"

Nous avons en quelques secondes un tableau explicite qui nous affiche les correspondances des dieux mythologiques.

Prenons juste un élément et regardons sa correspondance :

Tapons :

$h["Hermes"]

Manipuler les expressions régulières avec PowerShell

Les expressions régulières peuvent permettre de récupérer et de reformater des informations précises et en quantité, en effectuant par exemple des recherches sur du texte. Ce type d’usage avec les expressions régulières est couramment utilisé avec PERL.

Sous PowerShell tapez :

net config workstation

Notre objectif ici est de récupérer le nom du système d’exploitation « Windows » et la version « 2002 ».

Chaque ligne est accessible via un tableau. Ici c’est la sixième ligne qui nous intéresse.

Tapons :

$n = (net config workstation)[6]

Ici nous avons bien la ligne qui nous concerne.

Maintenant nous allons « matcher » (comparer les éléments) dans notre ligne pour récupérer les éléments de la façon suivante :

Le « .* » précise que c’est un ensemble de caractères qui se répètent.

Le « [^.] » précise que l’on prend tout ce qui n’est pas un point et plus.

Nous tapons la commande :

$n -match '^Version du logiciel.* (?<os>[^.]+)\ (?<vers>[^.]+)'

Nous obtenons un « True »…

… Ce qui veut dire que notre expression est correcte et que les éléments ont été récupérés.

Nous allons vérifier si nous avons récupérés les bonnes chaines de caractères.

Tapons :

$matches.os

$matches.vers

Nous avons réussi.

Le pipeline de données avec PowerShell

Le but est de canaliser et diriger des données, surtout quand nous en avons une grosse quantité à manipuler. Il ne faut pas perdre de vue que tout ce qui va circuler dans notre « pipeline » (ou pipe, symbolisé par « | ») ce sont des objets.

Premier exemple, tapons :

get-help | more

Le premier exemple de « pipe », utilisé couramment lors de la consultation de pages d’aides en ligne, est |more .Il permet de réduire la pagination en permettant de visualiser beaucoup de texte en donnant accès à des commandes comme « page suivante », « ligne suivante », ou encore « quitter ».

Un autre exemple permettant de récupérer les Get-Command set*, et de classer (« sort ») par types de commandes (« commandtype »).
Tapez :

get-command set* | sort commandtype

Donc, comme nous l’avons dit plus haut, ce ne sont pas des chaines de caractères qui nous sont renvoyées, mais…

… un tableau d’objets. Un .gettype() nous le prouve.

Et si nous allons contrôler en détail les lignes de ce tableau, en tapant :

(get-command set* | sort commandtype)[0].gettype()

Nous pouvons constater que ce sont des informations de type AliasInfo sur des commandes qui sont affichées.

Autre exemple de commande qui peut nous renvoyer des informations :

get-process | sort processname

Comme vous pouvez le voir, nous obtenons la liste des process actifs sur la machine, triés par les noms de process.

Et nous en avons la confirmation par :

(get-process | sort processname)[0].gettype()

PowerShell nous renvoie des informations de type process. Et encore une fois ce ne sont pas des chaines de caractères mais ce sont bien des objets.

Sous PowerShell on peut évidemment lancer la commande ipconfig.

Il est évident aussi que ipconfig ne sait pas qu’elle doit renvoyer des objets.

Si on tape (ipconfig).gettype()

On a confirmation qu’elle ne fait que renvoyer un tableau d’objets, mais ces objets ne sont que des chaines de caractères.

Tapons ceci :

(ipconfig)[0].gettype()

Cela veut dire que toutes les commandes qui existaient avant PowerShell renvoient des chaines de caractères, ce qui permet de travailler avec ensuite.

Autre exemple. Tapez :

netstat -e

Et si nous tapons :

(netstat -e) | where { $_ -like "*paquets*" }

Avec la commande where on demande de récupérer toutes les lignes qui contiennent le mot « paquets ».

Les filtres des pipelines de données

Nous allons passer à un niveau supérieur dans les commandes liées aux pipelines de données, en exploitant les filtres, permettant de modifier les commandes initiales.

Refaisons un get-process

Nous allons lancer un nouveau where sur un type de process en effectuant une recherche par nom de process. « $_ » désigne l’objet courant passé dans le « pipe ». Ici nous allons chercher le process se nommant « svchost ».

Tapons : get-process | where { $_.processName -eq "svchost"}

Nous pouvons formater la commande afin qu’elle ne renvoie seulement certaines parties de la réponse. Ce formatage s’effectue par format-table.

Tapez :

get-process | where { $_.processName -eq "svchost"} | format-table Processname,id –auto

Le format-table a gardé seulement les colonnes ProcessName et Id.

Nous pouvons aller plus loin, en donnant des instructions sur le process en cours.

Ici nous pouvons lancer un « stop-process ». Mais l’arrêt d’un process est une procédure agressive, donc nous allons ajouter le paramètre –whatif

get-process | where { $_.processName -eq "svchost"} | stop-process –whatif

Comme nous l’avons déjà dit précédemment, l’usage du paramètre –whatif permet d’éviter l’exécution réelle d’une commande, il ne fait que « simuler » l’arrêt du process, et affiche un résumé des conséquences d’une véritable exécution, ici celle d’un « stop-process ».

Autre exemple de commande plus agressive, tapons :

get-process | where { $_.processName -eq " svchost"} | stop-process –confirm

Le paramètre –confirm permet d’avoir une demande de confirmation avant d’appliquer la commande. Vu que nous avons plusieurs Process il propose de passer process par process, en demandant si Oui ou Non il applique la commande ([O], [N]) pour chacun des process, ou méthodes plus radicales Oui ou Non pour tous les process ([T], [U]). Nous allons répondre par la touche « U », non pour tout.

Une petite synthèse pour clôturer cette partie sur la manipulation d’objets :

(…) .gettype

Renvoie le type d’objet

(1) .gettype()

… | get-member

-membertype method

-membertype property

Renvoie les informations sur un objet

(…) | get-member

Get-childitem | get-member

-membertype method

[Math] | get-member

-static

Add-member

Ajoute un membre à un objet

New-object

Créer un nouvel objet

On n’accède jamais directement aux objets dans PowerShell, on y accède par l’intermédiaire d’adaptateurs qui sont chargés de créer une uniformisation du système de gestion des objets. L’idée de Microsoft est qu’il est possible, via PowerShell, de manipuler des éléments venant de l’environnement .Net, de l’environnement WMI, de l’environnement COM, et cela à partir du moment où ils ont été créés sous forme de variables ce sont tous des objets et se manipulent tous de la même façon. Comme on le voit sur le schéma « L’accès aux objet par PowerShell », on obtient un accès uniformisé aux objets.

Un résumé ci-dessous des Types .Net avec les Alias PowerShell :

Alias PowerShell

Type .NET Correspondant

Booléen

[bool]

System.Boolean

Numériques

[byte]

[int]

[long]

[float]

[double]

(decimal]

System.Byte

System.Int32

System.Int64

System.Single

System.Double

System.Decimal

Caractères

[char]

[string]

System.Char
System.String

Autres

[datetime]

[array]

[hashtable]

[xml]

[regex]

[math]

[psobject]

System.DateTime

System.Array

System.Collections.Hashtable

System.Xml.XmlDocument

System.Text.RegularExpressions.Regex

System.Math

System.Management.Automation.PSObject

Un tableau récapitulatif des nombres gérés par PowerShell :

Constantes

Entier (32 bits)

Long (64 bits)

Double,

Décimal

1 ou 0X10 (=16)

10000000000

1.1

123.45d

Suffixes

1KB (=1024)

2MB

2.1GB

Opérateurs arithmétiques

+ - * / %

9 * 3

Fonctions complexes

Via la classe [System.Math]

[math] ::Pi

[math] ::Max(2,7)

Pour plus de détails, tapez sous PowerShell : [math] | get-member -static

Ci-dessous un tableau récapitulatif des nombres et opérateurs sous PowerShell :

Opérateurs
d’affectation

=
+= -= *=
/= %=

$a = 1

$a += 5

($a = $a +5)

Opérateurs

unaires

++ --
. .

$a++ ($a = $a +1)

1..5 (1,2,3,4,5)

Opérateurs de comparaisons

-eq -ne -gt
-ge -lt -le

-like -notlike
-match -nomatch

-contains –nocontains
-replace

5 –eq ″5″ (= True)

5 –lt 1 (= False)

″un″ -like ″u*″ (= True)

Opérateurs
logiques

-and -or -xor

-not

-band -bor -bxor

-bnot

$false –or $false (= False)

-not $true (= False)

00xff –bor 0xaa (= 255)

-bnot 0xff (= -256)

Opérateurs sur
les types

-is -isnot

-as

3 –is [int] (= True)
″4″ -as [int] (= 4)

Autres

$ (…) évaluation de l’expression

> >> redirection de la sortie texte

@(…) tableau de résultats

2> 2>> 2&>1 redirection des erreurs

Pour plus de détails, tapez sous PowerShell : help about*operator*

Un tableau récapitulatif des instructions de contrôle de flux sous PowerShell :

Tests

if (<test1>) {<bloc-code1>}

[elseif (<test2>) {<bloc-code2>}]

[else {<bloc-code3>}]

switch –options (<pipeline>)

{ <pattern> {<bloc_commandes>}

<pattern> {<bloc_commandes>}

Default {<bloc_commandes>} }

help about_if

help about-switch

Boucles

while (<condition>) {<bloc_commandes>}

do {<bloc_commandes>} while (<condition>)

for {<init> ; <condition> ; <répétition>)

{<bloc-commandes>}

foreach ($<élément> in $<collections>)

{<bloc-commandes>}

help about_while

help about_for

help about_foreach

Avec des
cmdlets

foreach-object alias : %

where-object alias : 7

help foreach-object

help where-object

Ci-dessous un résumé des fournisseurs et magasins de données :

Magasins

Get-psprovider

Lecteurs

Get-psdrive

New-psdrive

Remove-psdrive

Résultats

Alias

Environment

Filesystem

Function

Registry

Variable

Certificate

Alias

Env

C, D,…

Function

HKLM, HKCU

Variable

Cert

PowerShell intégré au système

Regardons les lecteurs que nous avons à disposition sur notre machine en tapant la commande suivante :

Get-psdrive | sort provider,root

Nous récupérons par cette commande l’ensemble des lecteurs (Drives) disponibles, et par les accès visibles sur cette liste nous voyons que par PowerShell nous pouvons aller bien au-delà, car nous allons pouvoir parcourir les Alias, les variables d’Environnement, dans les Fonctions, et aussi aller dans la base de registre.

Tapons maintenant : Get-psprovider

Cette commande fournie tous les providers disponibles par le système.

Ce sont les providers définis par défaut, et il est possible d’en rajouter d’autres.

Si nous souhaitons aller sur le Drive Environment (Env), il suffit de taper la commande suivante :

cd env:

Ce n’est pas plus difficile que de rentrer sur un lecteur C ou D classique.

Si nous tapons la commande suivante :

Dir

Nous pouvons voir toutes les variables d’environnement, récupérer leurs valeurs, et nous pouvons nous en servir pour paramétrer des scripts.

Nous allons maintenant dans le magasin des Alias en tapant :

Cd alias:

Dir

Nous récupérons tous les Alias définis sur notre système.

Si nous tapons :

Cd hkcu:

Dir

Nous sommes rentrés dans la Registry, ce qui veut dire que notre base de registre est accessible et utilisable facilement par PowerShell.

Maintenant revenons sur le disque C : , tapons :

cd c:\

Traitement de fichiers avec PowerShell

Nous allons voir maintenant la manipulation de fichiers de type « Texte ».

Exemple :

$s = get-content $PSHOME\fr\about_Assignment_Operators.help.txt

Explications :

Nous allons demander la longueur de notre objet, en tapant : $s.length

En fait nous venons de récupérer dans notre variable $s le contenu d’un fichier présenté sous la forme d’un tableau contenant des chaines de caractères.

Chaque ligne est dans une chaine, et en demandant un .length nous avons obtenu le nombre de lignes de caractères, 444, contenues dans le fichier texte.

Nous allons taper : $s[12]

Nous venons d’effectuer une lecture de la ligne n°12 du fichier texte.

Si nous ouvrons dans le bloc note le fichier about_Assignment_Operators.help.txt, nous avons exactement cette ligne du fichier d’aide. Ceci nous confirme que nous obtenons bien des lignes de caractères dans un tableau.

Maintenant utilisons une fonction « join », et faisons lui concaténer l’ensemble dans notre variable $s.

Tapons : $s = [string]::join("",$s)

Tapons ensuite :

$s.length

$s[12]

En fait nous venons de lui demander de supprimer les espaces entre les caractères et les retours de lignes. Nous n’avons plus qu’un tableau contenant que des caractères. Donc le « O » affiché suite à la commande $s[12] correspond au 12me caractère.

Nous pouvons aussi travailler sur des mots (words).

Il existe une fonction permettant de « splitter » (qui pourrait se traduire par séparer) selon un espace ou une tabulation.

Tapons : $words = $s.split(" `t",[stringsplitoptions]::RemoveEmptyEntries)

En tapant un $words.length nous avons 2454 mots distincts dans le fichier initial.

Nous pouvons obtenir plus d’informations sur la fonction split en tapant :

Get-help split –full | more

Tapons maintenant : $uniq = $words | sort -uniq

La variable unique nous permet de supprimer tous les mots en double de la variable.
Et tapons ensuite : $uniq.count

Il ne nous reste plus que 554 mots uniques.

Maintenant passons à quelque chose de plus poussé, en utilisant le mécanisme de hachage, mécanisme vu dans la partie des tableaux associatifs ($h = @{}) plus haut dans notre tutoriel. Le type d’écriture que nous allons employer est à utiliser avec précautions selon l’usage que vous souhaitez en faire par la suite.

Tapons : $words | % { $h=@{}} {$h[$_] +=1}

Explications :

Puis tapons : $h | more

Regardons le résultat :

Le résultat faisant plusieurs pages, l’aperçu a été raccourci.

Nous obtenons un tableau avec une colonne de gauche qui liste les mots uniques, et la colonne de droite qui indique le nombre de fois que nous trouvons nos mots dans notre texte initial.

Comme nous avons un tableau de hachage des paramètres par défaut sont disponibles, qui nous permettent de récupérer par exemple le nombre de lignes distinctes.

Pour cela tapez :

$h.psbase.keys.count

Nous avons 554 lignes distinctes.

Maintenant nous allons grouper notre ensemble de mots et le trier en tapant :

$grouped = $words | group | sort count

Et nous pouvons voir ceux qui sont les plus utilisés en tapant :

$grouped[-1..-10]

Le résultat parle de lui-même.

Ces exemples avec la manipulation de textes donnent déjà une idée des applications possibles avec des journaux système.

Voyons cela en tapant :

Get-eventlog –list

PowerShell nous liste l’ensemble des fichiers de journaux système présents sur notre machine.

Tapons ceci :

Get-eventlog system | more

Nous venons d’accéder aux fichiers de journaux système, dont la liste est très longue, et encore une fois nous récupérons des objets, ceci étant de type « événements ».

PowerShell intégré avec WMI

Autre méthode permettant de manipuler des données traitant de l’état de notre système, c’est d’employer la commande get-wmiobject.

Tapons : get-wmiobject -list | more

Nous avons accès à l’ensemble des (très nombreuses) variables WMI (ou classes objets WMI) disponible sur le système.

Bien sûr il suffit de prendre la bonne classe WMI qui correspond à l’information que vous recherchez.

Tapons par exemple: get-wmiobject win32_computersystem

Nous pouvons aussi avoir besoin de récupérer des informations sur la mémoire virtuelle ou physique de notre machine.

Tapons :

get-wmiobject -class Win32_OperatingSystem -namespace root/cimv2 -computername . | Format-list TotalVirtualMemorySize, TotalVisibleMemorySize, FreePhysicalMemory, FreeVirtualMemory,FreeSpaceInPagingFiles

Mais là où ça devient très intéressant, c’est que WMI est activable à distance, par exemple en tapant :

get-wmiobject -class Win32_LogicalDisk -computername fabricer01

On obtient l’état WMI d’un poste précis dans le réseau à distance.

PowerShell intégré avec COM

Avec la commande $ui = new-object -ComObject "Shell.Application" , nous pouvons récupérer une boite de dialogue permettant d’obtenir un chemin de répertoire.

Tapons cette commande :

$path = $ui.BrowseForFolder(0, "Choisissez un répertoire, svp...",0,0)

Sélectionnons le répertoire « temp »…

Tapons ensuite : $path.Self.Path

Nous sommes bien sur le C:\temp.

Un autre exemple.

Tapons : $ie = new-object –com internetexplorer.application

Puis tapons :

$ie.navigate2("http://www.google.fr")

$ie.visible = $true

Que s’est-il passé ?

Nous avons créé un new-object –com d’application, placé dans une variable $ie, ici notre objet est l’application Internet Explorer, et nous lui avons passé une URL. Ici l’URL est "http://www.google.fr". Cette URL aurait très bien pu être locale. Par défaut cette URL ne s’affiche pas. On l’affiche en mettant un visible = $true sur notre objet $ie.

Maintenant nous allons voir à titre de démonstration un exemple de code plus poussé. Ce code montre comment créer des boites de dialogues faisant appel à la bibliothèque Windows.Forms.

Cette bibliothèque se charge de cette façon :

[reflection.assembly]::LoadwithPartialName("System.Windows.Forms");

Et ensuite on lance le reste du code :

$form= new-object system.windows.forms.form

$form.topmost = $true

$button= new-object system.windows.forms.button

$button.dock = “Fill”

$button.text = “PowerShell for ever ! :-) “+ (get-date)

$button.add_Click({$button.Text = (get-date)})

$form.Controls.add($button)

$form.showdialog()

On obtient :

Notre boite de dialogue est un bouton, qui par un clic dessus change l’affichage.

Un tableau récapitulatif sur la manipulation des fichiers sous PowerShell :

Commandes de déplacement dans l’arborescence

Get-location

Set-location

Push-location

Pop-location

Pwd

Cd, chdir

Commandes sur les chemins

Test-path

Resolve-path

Split-path

Convert-path

Gestion des éléments (fichiers, clés de registres,…)

New-item

Copy-item

Get-item, Set-item

Get-childitem

Move-item

Rename-item

Clear-item

Remove-item

Invoke-item

Get-acl, Set-acl

Rm, Rmdir

Commandes sur le contenu

Get-content

Set-content

Add-content

Clear-content

Cat

Ci-dessous un tableau résumant les manipulations de texte sous PowersShell :

Constantes

« abc »

Opérateurs

ab″ + ″cd″ (= ″abcd″)

″ab″ * 2 (= « abab″)

Fonctions sur les chaînes

[string] ::join

[string] ::split

[string] | get-member -static

Expression régulières

Help about_Regular_Expression

Commandes de recherche

-string

Comparable à grep

Help select-string

Un tableau présentant les ordres de formatage sous PowerShell :

Formatage des données pour affichage ultérieur

Format-wide

Format-list

Format-table

Format-Custom

Dir | format-wide –column 3

Sorties textuelles

Out-null

Out-default

Out-host

Out-file

Out-printer

Out-host -paging

Sorties PowerGadgets

Out-chart

Out-gauge

Out-map

Ecriture directe

Write-host

Write-progress

Un tableau résumant les commandes d’accès au système sous PowersShell :

Date

Get-date

Set-date

Processus

Get-process

Stop-process

Services

Get-service

Set-service

New-service

Restart-service

Resume-service

Stop-service

Suspend-service

Journaux

Get-eventlog

New-object –TypeName

System.Diagnostics.EventLog Application, 192.168.1.81

WMI

Get-wmiobject

Get-wmiobject –list [-namespace xx]

Get-wmiobject –class xx –Namespace xx

Property xxx filter xxx

-ComputerName xxx –Credential xxx

Un résumé ci-dessous présentant la stratégie d’exécution sous PowerShell :

Contrôle ce qui peut être exécuté
Get-ExecutionPolicy

Set-ExécutionPolicy UnRestricted

· Set-ExécutionPolicy

Stratégie	Restrictions
Restricted	Par défaut Ne permet pas d’exécuter des scripts Commandes interactives seules
AllSigned	Permet d’exécuter des scripts Tous les scripts doivent être signés par un fournisseur de confiance
RemoteSigned	Permet d’exécuter des scripts Les scripts téléchargés doivent être signés par un fournisseur de confiance
UnRestricted	Permet d’exécuter des scripts : Le plus permissif ! Aucune signature digitale n’est requise

Plus de détails : help about_signing