I. Présentation du sujet

J’écris ce billet en guise d’introduction à ce que l’on pourrait comparer sommairement à une sorte de série “pour les nuls“. Loin de moi l’idée d’introduire une quelconque connotation péjorative dans cet article , mais au fil de mes expériences et des informations que j’ai pu glaner sur le net et autres ouvrages sur le sujet, j’ai pensé qu’un rappel des fondamentaux serait peut être utile à votre envol dans ce monde hostile qu’est le “scripting” ou le shell sous Windows.

En fait, j’imagine volontiers le désarroi d’un technicien ou administrateur sous Windows, qui n’a jamais ou très peu sollicité la ligne de commande, à qui on va exposer des concepts d’objets, de classes, de types, de collections, d’instances (pour le vocabulaire) sans compter des syntaxes condensées et complexes (pour la grammaire) manipulant des concepts obscurs du système.

• Du batch (en gros l’héritage du DOS) – Ca ressemble/ait à ça…Non ?

FOR /F "tokens=2,3 delims= " %%A IN ('PING -a %1') DO IF "%%B"=="[%1]" SET PC=%%A

A cette “époque” on manipulait uniquement des chaines et des fichiers…

• Du WMI (via la console depuis XP, Ca ressemble/ait à ça :

WMIC useraccount where "name like '%500'" get name

Cette fois, on manipule des objets et franchement avec cette console Microsoft vous simplifiait bien la tâche. Pas convaincu ? Essayez de lancer “wbemtest” pour voir !…

• Du VBScript (ou WSH) – Ca ressemble (toujours) à ça :

Set oNetwork = CreateObject("WScript.Network")
Set oDrives = oNetwork.EnumNetworkDrives
bExist = False
For i = 1 to oDrives.Count step 2
if oDrives.Item(i)=sUNC then
WScript.Echo "le chemin " & sUNC & _
vbCrLf & "est deja associe au lecteur " & oDrives.Item(i-1)
bExist = true
end if
Next …

Une petite connaissance de ce langage simple et structuré tel que VBSscript, est un atout indéniable pour appréhender Powershell plus sereinement. A ce propos, Microsoft fournit un guide de correspondance et d’équivalence des instructions vbscript vers Powershell : en ligne ici ou la version Word “vbscript_to_powershell.doc”

La première chose à admettre c’est que les tutoriels et autres formations que vous pourriez avoir sur Powershell, ne vous affranchiront pas d’une certaine maitrise (ou l’inverse ) du système Windows. Je parle ici du “noyau” et non des interfaces graphiques, outils ou autres consoles d’administration. En mode shell ou script, l’écriture du code consiste à utiliser des éléments et préciser des détails dont vous ne connaissiez peut être pas l’existence car masqués par l’interface. Autrement dit, le premier obstacle, trouver la technologie la plus adaptée à votre besoin, puis identifier les contraintes et/ou les valeurs pour que cela fonctionne.

II. Premier contact – La console (ou $Host)

En premier lieu, il vous faut ouvrir une console Powershell.exe (à l’instar de l’invite de commande “cmd.exe”) – De préférence, en tant qu’administrateur (n’oubliez pas le contrôle de compte utilisateur UAC)

Quelques trucs à savoir (pour plus de confort) :

• Complétion : Contrairement à l’invite de commande traditionnelle, les commandes Powershell et leurs commutateurs (options précédés par un tiret), ainsi que les membres des instances (que l’on verra plus tard) bénéficient de la “complétion”. C’est à dire que vous pouvez utiliser les “Tabulations” (touches [Tab] ou [Maj] + [Tab]) pour compléter vos lignes de code.

• Historique : La touche [F7] permet de rappeler l’historique des commandes tapées précédemment dans votre session. Utilisez les touches de curseur [Haut] ou [Bas] pour vous déplacer dans la fenêtre.

Appuyez sur [Entrée] pour rappeler et exécuter la commande sélectionnée, ou sur [Flèche Droite] pour rappeler la commande sélectionnée sans l’exécuter. Utilisez ensuite les flèches [Gauche] ou [Droite] pour modifier la ligne (Mode “insertion” par défaut).

Note : Depuis Powershell v3, il est possible d’utiliser la complétion au sein d’une ligne existante sans perdre la fin de ligne.

• Copier-Coller : Vous pouvez utiliser la souris dans la console ! afin de copier/coller du texte. Pour cela, vérifiez que les propriétés de la fenêtre PowerShell, sont bien configurées : Sous l’onglet “Options”, cochez la case “Édition rapide” (C’est normalement le cas par défaut).

1 – “Clic gauche maintenu” et glissement pour la sélection du texte qui doit apparaitre en surbrillance.
2 – “Clic droit” n’importe où = “copier” (La sélection passe dans le presse-papier)
3 – “Clic gauche” sur le point d’insertion désiré
4 – “Clic droit” = “Coller”

Vous voilà armé au minimum pour la suite.

III. La structure des commandes

A. Les applets de commandes “cmdlet”

Dans le monde Powershell, vous remarquerez que les applets de commandes (Les fameuses “cmdlet” que nous verrons plus tard) sont composées d’une paire (ou tandem pour mieux pédaler ) de la forme “verbe”-“nom” destiné à en faciliter la mémorisation.

Le résultat renvoie une “collection d’instances” (Concept sur lequel je reviendrais plus tard) – Dans l’immédiat, considérez que c’est une sorte de tableau avec des entêtes de colonnes, où chaque ligne représente un élément.

B. Les variables Powershell

J’ajoute quelques mots sur la notion des “variables Powershell” qui mériteraient certainement un développement plus complet, mais je pense que pour débuter, un usage basique de ces variables volatiles peut être un allié de poids. En effet, plutôt que d’écrire une commande complexe et vous arracher les cheveux pour des histoires syntaxiques, les variables vous permettent de décomposer chaque bloc ou élément de code, afin d’avancer à votre rythme.

• Une variable Powershell est un emplacement de stockage provisoire en mémoire destiné à recueillir une valeur, un objet ou une collection d’objets.
• Les variables sont généralement nommées, et leurs noms sont toujours précédés d’un symbole “$“
• Les variables sont automatiquement “typées” lors de l’affectation de valeur (si elles ne sont pas déclarées au préalable.)
• Il existe plusieurs commandes pour manipuler les variables, mais le plus simple reste la déclaration par instanciation via le signe d’égalité soit :

$Process = Get-Process

• La variable “Process” déclarée dans cet exemple, contient la liste des processus en cours, obtenus par la commande “Get-Process” Vous pouvez afficher son contenu en mentionnant simplement en stipulant son nom “$Process” puis “Entrée”

C. Les variables d’environnement

J’admets que c’est un peu hors sujet, mais j’ajouterais juste quelques mots en raison de la fréquence des questions sur ce point.

Les variables d’environnement sont accessibles de plusieurs manières :

• Via le lecteur PS (j’utilise “dir”, mais il faudrait plutôt utiliser “Get-ChildItem” ou “gci” …)

dir env:U*

• Via une variable PS

$(env:USERNAME)

• Via l’interpréteur traditionnel (c’est pas top, mais bon…)

cmd /c set U

Par exemple, pour afficher votre nom de login (en vert) dans une console Powershell :

write-host "Bonjour $(env:USERNAME)" –fore 'green'

D. Le pipeline

J’ai hésité à évoquer ce concept dans cet article d’initiation, mais son usage (et maitrise) est tellement important que je vais essayer de résumer rapidement ce concept.

Cette notion de pipeline, symbolisée par le caractère “|” ([AltGr] + [6]) permet de “chainer” plusieurs commandes entre elles.

Autrement dit, la sortie d’une commande est liée à l’entrée de la suivante. On peut considérer cet ensemble comme un tout, éventuellement destiné à une variable ou une fonction…

Un petit schéma pourrait être utile ?

Dans cette illustration, quelque peu abrupte j’en conviens , l’applet de commande “Get-Service” envoie son résultat (sortie) vers l’entrée de la commande “ForEach-Object” (aliassée par “%”). Cette seconde commande traite chacun des éléments de l’objet en cours ( Symbolisé par “$_” ) afin de traiter une seule propriété, en l’occurrence “Name”).

Amusez-vous avec ce petit exemple :

gsv | ogv

Bien pratique pour retrouver le nom d’un service sur une machine.

Note : L’applet de commande “ogv” nécessite le framework .NET 3.51 ou + (non activé par défaut sur Win2008R2)

IV. Les commandes de “Découverte”

Pour bien débuter en Powershell, je vais vous parler des commandes qu’il vous faudra impérativement maîtriser au plus vite. Les voici dans le tableau de synthèse suivant :

Cmdlet	Description	Alias
Get-Command	Informations de base sur les commandes	gcm
Get-Help	Aide de base (utiliser -full ou -example)	help, man
Get-Member	Informations sur les méthodes et propriétés des objets	gm
Get-PSDrive	Informations sur les “lecteurs” PowerShell	gdr
Get-Module	Liste les “modules” actuellement chargés	gmo
Get-PSSnapin	Liste les “snapins” actuellement chargés	gsnp

Vous comprendrez par la suite l’importance primordiale de ces quelques commandes parmi les nombreuses autres commandes intégrées, dites “cmdlets” (129 en PSv1, 236 en PSv2, …).

Maitrisées, ces applets de commandes* devraient vous permettre de débroussailler la plupart de vos questions (légitimes) de néophytes.

Pour les plus impatients, essayez ces quelques commandes :

Pour afficher la version de Powershell :

$Host.version.major

Pour compter ces fameuses “cmdlet” ou applets de commande Powershell :

(Get-Command –CommandType cmdlet).count

Au début, concentrez votre attention sur les applets en commande, c’est-à-dire les “cmdlet”.

En effet, bien que pratiques au quotidien, les alias, les fonctions, les scripts, les modules ou même les “applications”, sont très utiles mais sont de véritables pièges pour les non-initiés.

A mon avis, les débutants ne doivent pas abuser des “alias”, car je pense qu’ils les desservent plus les qu’ils ne les aident. (ie : dir /s –> Get-ChildItem –Recurse )

Petite précision importante : Powershell n’est pas sensible à la casse (Majuscules/minuscules), ni aux espaces, ou tabulations superflues.En fait, vous verrez que Powershell est par défaut très tolérant, peut-être même trop parfois….

A. “Get-Help” – L’anti-sèche ou l’ami de tous les instants

Powershell est “auto-documenté” : N’hésitez-pas à solliciter l’aide intégrée via : GET-HELP

C’est sans doute la première commande à connaitre

Pour obtenir de l’information sur une commande, ou un sujet quelconque : “GET-HELP” ou “HELP” ou “MAN” ou encore “HELP HELP”

En ajoutant éventuellement les commutateurs : “-Example” ou “-Full” ou “-Detailed” ou “-online” (Notez que les exemples fournis sont pleinement fonctionnels)

En fait, la documentation de l’aide est contenue dans les fichiers “about_*”

Ces fichiers sont situés dans le dossier : “C:\Windows\System32\WindowsPowerShell\v1.0\fr-FR\” Ou bien en code Powershell

gci $PSHOME+"\"+$PSCulture

Note : Ne vous attardez pas sur le “v1.0″ du chemin qui reste invariable quelle que soit la version de Powershell. A l’instar de “system32″ qui contient des binaires 64bits sur un système 64 bits : Les binaires 32 bits étant dans SysWOW64 !

Dans la pratique, la commande “Help” effectue une recherche intégrale dans les fichiers “About_” (à l’instar d’un Grep Unix – “Select-String” en PowerShell) – L’aide affiche des propositions si le nom n’est pas correspond pas à un terme reconnu. Essayez par exemple les commandes suivantes en oubliant volontairement le “s” à la fin….

HELP Alia
HELP Operator

Remarque : Powershell v3 n’intègre plus qu’une aide locale partielle – Vous pouvez utiliser l’aide en ligne si la machine dispose d’un accès Internet et/ou “Update-Help” (Également disponible dans l’éditeur graphique Powershell ISE) – Il faut être administrateur pour réaliser cette action.

Note : Une version .CHM de l’aide (de base) sur PowerShell est disponible ici.

B. “Get-Command” – Une commande incontournable !

Usez et abusez de cette commande pour tout savoir sur les commandes disponibles, l’origine ou le type d’une commande particulière, les commandes propres à un module…L’alias de “get-command” est “gcm”. Une petite explication s’impose :

Si vous souhaitez connaitre la liste des commandes disponibles, essayez d’entrer les commandes suivantes :

(gcm).count
(gcm * ).count
(gcm -CommandType cmdlet).count

Le nombre renvoyé est différent parce que Powershell est en mesure d’exploiter différentes catégories de commandes :

Catégorie	Description
Alias	Pointeur ou nom alternatif affecté à une applet de commande, une fonction ou une application
Function	Bloc d’instruction nommé ou suite de commandes existant en mémoire uniquement le temps d’une session PS ou d’un script (analysée une seule fois) – Le contenu d’une fonction peut être affiché, comme par exemple “gc function:\mkdir”
Cmdlet	Commandes prédéfinies / compilées (Généralement elles offrent un accès convivial et simplifié aux classes du Framework .Net)
Application	Fichier exécutable se trouvant dans le PATH , par exemple:gcm ipconfiggcm notepadgcm where

 

Je n’ai pas encore abordé ce sujet, mais sachez d’ores et déjà que Powershell dispose d’un noyau constitué de commandes (alias, function, cmdlet) de base qui peuvent être complétées à la demande par le chargement de “modules” complémentaires.

Les modules sont apparus avec la version 2 de Powershell et tendent à se généraliser (ils portent généralement l’extension *.psm1, ou *.psd1, parfois *.dll lorsqu’ils sont compilés). Les modules sont généralement spécialisés pour la gestion des fonctionnalités et rôles propres à une machine. (Par exemple, le module “ServerManager” n’est disponible que sur les versions Windows Server 2008R2 et ultérieures).

Pour connaitre les modules disponibles sur votre machine :

get-module –ListAvailaible

pour charger un module dans le contexte de la session ou d’un script :

import-module NomDuModule

Indiquez le chemin complet, si celui-ci n’est pas enregistré ni proposé dans la liste précédente.

Note : Le chemin de recherche des modules est stipulé dans la variable d’environnement “$env:PSModulePath”

Vous pouvez “décharger” un module de la mémoire via la commande : remove-module (Rassurez-vous, cela ne détruit pas le module).

Et enfin, pour connaitre les commandes “apportées” par un module chargé en mémoire :

gcm –module NomDuModule

Pour conclure sur cette fameuse applet de commande “Get-Command” ou “gcm”, entrez l’instruction suivante pour énumérer toutes les commandes et les classer par verbes en ordre décroissant.

gcm –CommandType cmdlet | group verb | sort count –Descending

Amusez-vous à regarder et comprendre les inégalités entre “start|stop”, “New|Remove”, “Export|Import”. C’est parfois logique, parfois un peu moins … (Vous n’avez pas déjà oubliez l’aide ?!…)

C. “Get-Member” – L’explorateur d’objets (la clé du succès)

Bon maintenant, il va falloir passer aux choses sérieuses. Avant de parler de cette commande “Get-Member”, je me dois de vous présenter le plus simplement possible, le concept complexe des objets :

Un petit peu de vocabulaire s’impose:

Terme	Explication
Classe	C’est un peu comme le “Plan de construction” – aussi appelé “Type” de données
Instance	“Objet existant (élément) – construit selon une classe”
Collection	Désigne un “Ensemble d’instances” (généralement d’un même type ou associé)”
Variable	C’est un contenu nommé, ou le stockage d’une collection dans une zone mémoire
Membres	Ce sont les “Caractéristiques” (Propriétés) et les “Capacités” (Méthodes) d’un objet.

Bien, regardons cette notion de membre d’un peu plus près via cette petite illustration :

Une classe de type “Boite”, va nous permettre de construire une ou plusieurs boites similaires (instance). Nous pourrons ensuite consulter (voir modifier) les caractéristiques (Propriétés) telles que la taille, la couleur, etc. De la même manière, nous pouvons agir sur une boite et ses capacités (Méthodes) telles que l’ouvrir, la fermer, etc…

Note : Sur le plan syntaxique, les membres (propriétés ou méthodes) sont liés à l’objet (l’instance) par un point “Instance.Membre” et par un double “::” pour les membres statiques du Framework .NET “[Type.NET]::Membre”

Un membre statique est une notion particulière que l’on pourrait définir comme membre ayant la particularité d’être sollicité directement via la classe sans nécessiter d’instance. Comme par exemple :

[datetime]::now

Bien, maintenant que le décor est planté, essayons de revenir à un exemple plus concret et pratique. Sous Powershell, tout est objet. Une simple chaine de caractère est donc un objet de type [string] doté de propriétés et de méthodes.

Vous imaginez peut être quelques possibilités telle que la longueur de la chaine (“.length”), mais probablement moins l’étendue de toutes ses possibilités. En premier lieu, interrogez le type du contenu “Chaine” via l’instruction suivante :

("Chaine").gettype()

Normalement, vous obtenez “String” dans le résultat. Maintenant, regardez d’un peu plus près les possibilités en tapant la commande suivante :

"Chaine" | get-member

ou plus simplement

“Chaine” | gm

Parmi toutes les informations renvoyées, vous devriez apercevoir le type “TypeName : System.String”, ainsi qu’une liste conséquente de méthodes et de propriétés. Essayez de les utiliser comme dans les exemples suivants :

(“Chaine”).length –> 6
(“Chaine”).ToUpper() –> CHAINE
(“Chaine”).Replace(“C”,”Déc”) –> Déchaine

Note : Pour invoquer une méthode (sans paramètres), vous devrez ajouter les parenthèses à la fin “.Method()”.

Ultime précision, et bien qu’il s’agisse d’un concept avancé qui ne devrait pas apparaitre ici, sachez qu’il est possible d’obtenir la liste des membres statiques d’un type .NET via la commande suivante :

[string] | get-member -static

Voilà, je pense que j’ai fait le tour des fondamentaux. J’ajouterais peut être un complément dans les mois à venir. Maintenant, il ne vous reste plus qu’à digérer tout cela et surtout à pratiquer sans modération.

Pour lire la deuxième partie de ce cours : PowerShell pour les débutants (Partie 2)

La connaissance s’acquiert par l’expérience, tout le reste n’est que de l’information. Bon courage.