Résumé

La complexité des infrastructures Microsoft (Windows Server, Active Directory, Exchange Server, SCCM, SCOM, etc.) rend nécessaire de disposer d’un ensemble d’outils cohérents pour aider les administrateurs et les ingénieurs en charge d’automatiser les processus en œuvre dans le système d’information. C’est chose faite grâce à PowerShell dont l’arsenal, très vaste, comprend à la fois un langage de script et un environnement en ligne de commande, et dépasse largement les fonctionnalités proposées par VBScript.

Une référence pour l’administrateur en environnement Microsoft

À jour de la dernière version de PowerShell, cet ouvrage avancé met en pratique le langage dans de très nombreux cas concrets de tâches d’administration.

Après avoir exposé les connaissances fondamentales à l’utilisation de PowerShell (environnement en ligne de commande, environnement de scripting, syntaxe, principe du pipeline, format des données, manipulation des objets, sécurité), puis chaque élément du langage (variables, opérateurs, tableaux et dictionnaires, boucles, contrôle de flux, fonctions, modules et gestion d’erreur), cet ouvrage met en pratique ces connaissances théoriques avec WMI, les services, les logs, la base de registres, COM et XML. Le lecteur verra ensuite comment administrer des machines à distance, utiliser les workflows, manipuler les expressions régulières, automatiser la gestion de l’Active Directory, mieux connaître le framework .NET, et développer des interfaces graphiques facilitant l’utilisation des scripts écrits.

Au sommaire

Les bases • Commandes natives Windows • Comparer sur la base de propriétés d’objets • Filtrer les objets • Effectuer des opérations sur chaque objet • Créer des objets • Variables automatiques • Opérateurs de comparaison • Opérateurs d’affectation • Opérateurs de redirection • Opérateurs de fractionnement et de jointure • Opérateurs spéciaux • Tableaux et dictionnaires • Boucles • for • foreach • do…while • do…until •while • Instructions conditionnelles • if…else • if…elseif…else • switch • Fonctions • Déclarer • Paramètres • $args • Documenter • Syntaxe de l’aide • Description des mots-clés • Modules • Écrire un module en langage PowerShell • PSSnapins • PowerShell et la gestion d’erreur • Différencier l’erreur de l’exception • Anatomie d’une erreur • Paramètre -ErrorAction et la variable $ErrorActionPreference • Instruction trap • Instruction try…catch…finally • PowerShell en pratique • L’infrastructure WMI et CIM • Les cmdlets WMI • WMI en pratique • Les cmdlets CIM • CIM en action • Gérer les services • Lister les services • Démarrer, arrêter, redémarrer et interrompre l’exécution d’un service • Configurer le mode de démarrage d’un service • Modifier le compte de connexion d’un service • Gérer les logs • Lister • Configurer et sauvegarder • Supprimer • Gérer la base de registre • Naviguer dans la base de registre • Chercher, ajouter et effacer un élément de registre • La base de registres à distance • PowerShell et COM • Manipuler un objet COM • Automatiser Internet Explorer • Mapper un lecteur réseau • Utiliser l’objet FileSystem • Créer un fichier texte • Lire un fichier texte • PowerShell et XML • Manipuler un fichier XML • Les cmdlets Export-Clixml et Import-Clixml • Rechercher des informations à l’aide de la cmdlet Select-Xml • Configurer l’accès à distance • Connexions temporaires et persistantes • Quel type de connexion privilégier ? • Se déconnecter d’une session pour se reconnecter plus tard • Workflows sous PowerShell • Workflows comme synonyme de productivité • Relation PowerShell-WWF • Différence workflow/fonction • Paralléliser des opérations • Effectuer des opérations de manière séquentielle • Instruction InlineScript • Expressions régulières • Classe [Regex] • Opérateurs -match et -notmatch • cmdlet Select-String • Automatiser l’Active Directory • Administrer les utilisateurs et groupes de l’Active Directory • Créer un domaine Active Directory • Zones DNS de recherches directes et inversées • Utiliser le framework .NET • Ajouter un type • Envoyer un e-mail • Collecter des informations DNS • Développer une interface graphique avec PowerShell • Windows Forms ou Windows Presentation Foundation • PowerShell Studio 2012 • Créer une interface graphique • Écrire le code • PowerShell sous Linux : rêve ou réalité ? • Gérer les services • Gérer les modules kernel • Gérer les disques.

À qui s’adresse cet ouvrage ?

– Aux ingénieurs et administrateurs systèmes et réseaux Microsoft souhaitant automatiser efficacement leurs opérations d’administration

– Aux programmeurs désirant automatiser le déploiement et la configuration de leurs applications

– Aux ingénieurs et administrateurs venant du monde Unix/Linux et évoluant dans des environnements hétérogènes

Biographie auteur

K. Ayari

Kais Ayari, PowerShell Guru et Scripting Specialist, a notamment travaillé chez Microsoft en tant qu’expert et référent technique PowerShell. L’auteur a pensé et conçu l’architecture d’une version de PowerShell sous Unix/Linux, ce qui fait de lui l’un des meilleurs experts au monde sur cette technologie. Il collabore également avec les éditions Manning en apportant son expertise technique sur PowerShell.

www.editions-eyrolles.com

Scripting avancé
avec Windows
PowerShell

Une référence pour
l’administrateur et le développeur

Automatisation • XML • Services et logs • Sécurité • COM • WMI • CIM • Pipeline • Expressions régulières • Modules • Remoting • Workflow • Active Directory • .NET

Kais Ayari

ÉDITIONS EYROLLES

61, bd Saint-Germain

75240 Paris Cedex 05

www.editions-eyrolles.com

Attention : la version originale de cet ebook est en couleur, lire ce livre numérique sur un support de lecture noir et blanc peut en réduire la pertinence et la compréhension.

En application de la loi du 11 mars 1957, il est interdit de reproduire intégralement ou partiellement le présent ouvrage, sur quelque support que ce soit, sans l’autorisation de l’Éditeur ou du Centre Français d’exploitation du droit de copie, 20, rue des Grands Augustins, 75006 Paris.
© Groupe Eyrolles, 2014, ISBN : 978-2-212-13788-0

Retrouvez aussi nos livres numériques sur
http://izibook.eyrolles.com

Avant-propos

Depuis ses débuts, Windows n’a jamais véritablement eu d’interpréteur de commandes, mis à part le classique (et très rudimentaire) cmd.exe qui émule partiellement MS-DOS. En effet, Microsoft n’a jusqu’à présent jamais promu la gestion du système d’exploitation en ligne de commande, l’idée ayant toujours été de recourir à une interface graphique, pour que les outils soient utilisables à la souris. Le shell fournissant un nombre très réduit de commandes, les utilisateurs (administrateurs, ingénieurs…) ont privilégié les outils dotés d’interface graphique.

Cette politique a eu, on ne peut le nier, des conséquences dévastatrices sur le comportement des utilisateurs, dans la mesure où elle les a rendus à leur insu très réticents à la ligne de commande, sinon rebelles. Le hiatus avec le monde Unix/Linux s’est profondément accentué au fil des années ; il n’a jamais été dans la culture de l’administrateur Windows...

1

Qu’est-ce que PowerShell ?

Avant toute étude des particularités de PowerShell, il est indispensable de faire connaissance avec cette technologie. Sa richesse et sa complexité requièrent une approche graduée. Nous verrons donc comment accéder au shell, qui est l’interface en ligne de commande. Puis, nous explorerons l’environnement de scripting, ou ISE (Integrated Scripting Environment). PowerShell fournit une aide extrêmement utile, qui évite de recourir systématiquement à Internet pour résoudre des problèmes ; apprendre à l’utiliser est donc un élément capital pour être plus efficace dans une démarche où le temps est très précieux. Enfin, nous énumérerons les nouveautés de la dernière version de PowerShell, la version 3.

SOMMAIRE

Découvrir le shell

L’environnement de scripting

L’aide intégrée

Les nouveautés liées à PowerShell v3

Découvrir le shell

Ce que l’on nomme shell dans la perspective de cet ouvrage est l’interface en ligne de commande, ou CLI (Command-Line Interface). Cela dit, un shell peut aussi être de type graphique. Lorsqu’un utilisateur navigue dans l’explorateur Windows, il utilise un shell graphique. Mais beaucoup d’utilisateurs réduisent la signification du mot shell au sens d’interface en ligne de commande, ignorant que ce mot a d’autres acceptions.

Comment lancer la console ?

PowerShell est disponible d’emblée dans Windows 8 (sans vouloir évoquer les autres versions de ce système). Pour y accéder, nous pouvons au moins citer deux méthodes.

Pour la première méthode :

1 Écran Démarrer.

2 Taper PowerShell avec votre clavier.

3 Cliquer sur l’icône Windows PowerShell qui apparaît.

Pour la seconde méthode :

1 Déplacer le curseur de la souris jusqu’au coin en haut à droite du Bureau.

2 Cliquer sur Rechercher.

3 Taper PowerShell avec votre clavier.

4 Cliquer sur l’icône Windows PowerShell qui apparaît.

La console s’affiche alors à l’écran.

Figure 1–1
Console PowerShell lancée depuis Windows 8

Comme on le voit, l’interface est tout à fait classique et ne présente pas de particularités esthétiques évidentes. D’ailleurs tel n’est pas son but. Essayons simplement d’obtenir la liste des fichiers et répertoires.

Figure 1–2
Lancement d’une commande de base

En tapant la commande ls, on obtient une liste ordonnée de répertoires. C’est donc du texte. C’est évident me direz-vous, mais en réalité, nous avons ici toute une série d’objets (que nous étudierons plus tard dans cet ouvrage).

Voilà donc à quoi ressemble la console PowerShell. Surtout, il ne faut pas se fier aux apparences. En effet, PowerShell est extrêmement robuste, permettant d’accéder à quasiment tout le système d’exploitation. Le framework .NET est le...

2

Les bases de la syntaxe

Dans sa syntaxe, PowerShell dérive de plusieurs langages. Sa grammaire s’est structurée essentiellement à partir de Korn Shell, à la base également d’autres langages de scripts. Par ailleurs, on reconnaît dans certaines structures les langages C, C#, Perl, PHP ainsi que Tcl, pour ne citer que les plus connus.

Dans ce chapitre, nous allons aborder les éléments de base qui constituent le fondement de PowerShell. D’abord, nous essaierons de définir ce que regroupe le mot commande, puis nous expliquerons ce que sont les paramètres et les modes d’analyse syntaxique, nous évoquerons les alias et enfin les blocs de script.

SOMMAIRE

Comprendre les commandes

Les paramètres

Les modes d’analyse syntaxique

Les alias

Les blocs de script

Les commandes

En PowerShell, le terme « commande » a plusieurs acceptions. Il peut signifier :

• les cmdlets ;

• les fonctions ;

• les scripts ;

• les commandes natives Windows.

Définir ces termes est une démarche fondamentale pour acquérir les bases.

Les cmdlets

Une cmdlet ou applet de commande (appelée command-let) est un ensemble de données structurées dans une classe .NET. Ces données regroupent le nom de la cmdlet, les types de ses paramètres, sa description, son comportement vis-à-vis des autres cmdlets, etc. Lorsque cette classe est implémentée, elle est compilée dans une DLL (Dynamic Link Library). Cette dernière peut ensuite être importée lors d’une session en cours, ou alors être chargée au démarrage d’une session.

NOTE Sur le mode de fonctionnement des cmdlets

Lorsqu’une session PowerShell est démarrée, les bibliothèques (ou DLL) sont chargées automatiquement, ce qui rend l’exécution des cmdlets plus rapide que celle des autres catégories de commandes.

Les cmdlets respectent des règles de nommage bien précises. Le format qu’elles adoptent est de type Verbe-Nom.

• Le verbe décrit le genre d’action à mener.

• Le nom décrit l’objet sur lequel nous voulons accomplir cette action.

Par exemple, la cmdlet Get-Service respecte parfaitement ce format.

• Le verbe Get signifie « obtenir ».

• Le nom Service signifie un objet ou une liste d’objets représentant les services.

Cela signifie en clair : « Lister un ou plusieurs objet(s) représentant les services. »

À SAVOIR Deux façons d’écrire des cmdlets

Depuis la version 2 de PowerShell, il est possible, et c’est une bonne chose pour les administrateurs qui ne sont pas programmeurs, d’écrire des cmdlets en langage PowerShell sous la forme de fonctions avancées (voir chapitre 12), et non plus seulement en langage .NET comme C#.

RESSOURCE Liste des verbes approuvés

http://msdn.microsoft.com/en-us/library/windows/desktop/ms714428%28v=vs.85%29.aspx

Figure 2–1
Liste des verbes approuvés pour écrire des commandes PowerShell

Il n’est absolument pas nécessaire d’utiliser des verbes de cette liste mais cela est fortement recommandé, car des problèmes peuvent sinon survenir. Par exemple, la commande Get-Command peut avoir des difficultés à détecter de nouvelles cmdlets ne...

3

Le pipeline

Le pipeline est sûrement l’élément le plus partagé entre les différents interpréteurs de commandes. Pourtant, la façon dont il fonctionne avec PowerShell est tout à fait particulière en bien des aspects. De plus, même si cet élément est quasi transparent quant à son fonctionnement, maîtriser ses aspects est une condition sine qua non à la maîtrise de PowerShell.

Nous nous familiariserons donc avec le principe de fonctionnement du pipeline, puis nous évoquerons la liaison des paramètres, qui est très directement liée au pipeline. Enfin, nous examinerons les erreurs de pipeline pouvant causer l’échec d’une commande.

SOMMAIRE

Principe et fonctionnement du pipeline avec PowerShell

La liaison des paramètres

Examiner le pipeline

Principe et fonctionnement du pipeline

Comme dans tous les interpréteurs, il est possible d’invoquer plusieurs commandes simultanément dans la même ligne. Toutefois, cela nécessite un moyen puissant pour les mettre en articulation : le pipeline.

Qu’est-ce qu’un pipeline ?

Un pipeline est un moyen par lequel des commandes peuvent communiquer les unes avec les autres. Le principe est qu’une commande_1 envoie sa sortie à la commande_2, qui elle-même, après avoir traité le flux entrant, envoie sa propre sortie à la commande_3, et ainsi de suite. Cette communication se fait via l’opérateur |. Donc, il peut y avoir autant d’opérateurs | que nécessaire.

Chaîne de commandes sollicitant le pipeline

Commande_1 | Commande_2 | Commande_3 | Commande_4

Le principe du pipeline est, par conséquent, de réaliser une chaîne de commandes. Il en résulte un flux d’objets à travers l’ensemble des commandes visées.

À SAVOIR Ordre dans lequel s’exécutent les commandes

En PowerShell, les commandes sont exécutées de gauche à droite. En outre, l’ensemble de la chaîne est considéré comme une unité d’exécution.

L’architecture des cmdlets est conçue de telle sorte qu’elles soient communicatives. Ainsi, une cmdlet qui a pour verbe Get est destinée à envoyer des objets à d’autres cmdlets d’action, ayant comme verbes Stop, Set, Start, New, Suspend, Rename… Par exemple, prenons la liste des commandes liées à la gestion des services :

PS> Get-Command -Noun Service

CommandType | Name
----------- | ----
Cmdlet | Get-Service
Cmdlet | New-Service
Cmdlet | Restart-Service

...

4

Manipuler les objets avec PowerShell

La particularité ultime de PowerShell est qu’il est orienté (ou basé) objet, et non pas texte comme on pourrait le penser de prime abord. La différence est fondamentale, car cette orientation peut parfois dérouter certains utilisateurs, par exemple ceux venant du monde Unix/Linux.

Dans ce chapitre, nous clarifierons ce qu’implique ce concept. Puis nous apprendrons à maîtriser, trier, grouper, comparer, filtrer, modifier et créer des objets avec PowerShell.

SOMMAIRE

PowerShell est purement orienté objet

Maîtriser les flux : Select-Object

Trier : Sort-Object

Grouper : Group-Object

Comparer : Compare-Object

Filtrer : Where-Object

Effectuer des actions sur chaque objet : Foreach-Object

Créer : New-Object

PowerShell est purement orienté objet

La base de développement de PowerShell est le framework .NET, ce qui oriente cette technologie vers le mode objet, même si nous ne voyons à l’écran que du texte. Cette information est importante, car il est essentiel de comprendre le contexte dans lequel nous évoluons.

Qu’est-ce qu’un objet ?

Un objet est un ensemble de données définissant une entité. À ce titre, on peut considérer un objet comme une entité sur laquelle on peut agir d’une certaine façon et dans un contexte qui lui est propre. La structure d’un objet est définie en trois parties :

• le type de l’objet ;

• ses méthodes ;

• ses propriétés.

Le type d’un objet représente sa nature. Les méthodes d’un objet servent à le manipuler (le modifier, changer son état à un moment donné). Les propriétés d’un objet donnent des informations sur son état. Pour prendre un exemple concret, le tableau suivant (non exhaustif) illustre les différents types de données d’un objet représentant un service Windows.

Tableau 4–1 Structure d’un objet représentant un service

Membre | Type de donnée | Description
Nom du service | Propriété | Obtient le nom qui identifie le service.
Nom de l’ordinateur | Propriété | Obtient le nom de l’ordinateur sur lequel le service réside.
Type de service | Propriété | Obtient le type de service référencé par l’objet.
Statut | Propriété | Donne l’état du service.
Peut être arrêté ? | Propriété | Indique si le service peut être arrêté après avoir démarré.
Démarrer | Méthode | Démarre le service.
Arrêter | Méthode | Arrête le service.
Interrompre | Méthode | Interrompt le fonctionnement d’un service.
Continuer | Méthode | Permet de reprendre le fonctionnement d’un service après qu’il a été suspendu.

Un objet est donc un moyen par lequel il est possible d’agir sur un composant, ici un composant Windows. Par conséquent, manipuler un objet peut être très dangereux.

Utiliser un objet

Maintenant que nous savons ce qu’est un objet, essayons d’en utiliser un de manière simple et claire. Prenons l’exemple d’une chaîne de caractères que nous encapsulerons dans une variable, de telle façon que l’objet constituant la chaîne soit utilisable via la variable :

PS> $var = "PowerShell"

Ici, nous avons créé une variable nommée $var et lui avons affecté la valeur PowerShell. Comment la manipuler ? Quels sont les membres que nous avons à notre disposition ? Une cmdlet peut nous aider à répondre : Get-Member, qui renvoie les propriétés et méthodes des objets. Interrogeons-la :

PS> $var | Get-Member

TypeName : System.String

Name | MemberType | Definition
------ | ---------- | -----------
Clone | Method | System.Object Clone(), Syste
CompareTo | Method | int CompareTo(System.Object
Contains | Method | bool Contains(string value)
CopyTo | Method | void CopyTo(int sourceIndex,
EndsWith | Method | bool EndsWith(string value),
Equals | Method | bool Equals(System.Object ob
GetEnumerator | Method | System.CharEnumerator GetEnu
GetHashCode | Method | int GetHashCode()
GetType

...

5

PowerShell et la mise en forme des données

Lorsque PowerShell affiche les données, elles peuvent prendre différents aspects, auxquels l’utilisateur ne prête pas forcément attention. La mise en forme des données est un des points centraux du fonctionnement de PowerShell.

Dans ce chapitre, nous étudierons les différents systèmes de mises en forme, à savoir comment distinguer une vue sous forme de tableau de celle sous forme de liste, la personnalisation de l’affichage ainsi que l’affichage d’une seule propriété sous la forme d’une large table.

SOMMAIRE

Afficher les données de sortie sous forme de tableau : Format-Table

Afficher les données de sortie sous forme de liste : Format-List

Personnaliser l’affichage des données de sortie : Format-Custom

Afficher une seule propriété sous forme de table : Format-Wide

PowerShell structure les données de sortie à partir des informations contenues dans une base de fichiers XML : à chaque fois qu’une commande est exécutée, il interroge la base de données interne afin d’afficher les objets correctement. Par défaut, lors de l’installation de PowerShell, la base est placée dans C:\Windows\System32\WindowsPowerShell\v1.0.

ASTUCE Pour éviter d’avoir à écrire souvent ce même chemin d’accès

Pour simplifier vos lignes de commandes, vous pouvez utiliser la variable $PSHOME, qui contient le chemin d’accès complet menant au répertoire d’installation de PowerShell.

La particularité de cette base de données de mise en forme est que chacun des fichiers qui la constituent contient dans son nom le mot format. Regardons cette liste de fichiers :

PS> Get-ChildItem $PSHOME\*format*

Répertoire : C:\Windows\System32\WindowsPowerShell\v1.0

La disposition des objets lors de leur affichage, de l’aide intégrée et de tout ce qui nécessite une mise en forme est contenue par défaut dans cet ensemble de fichiers XML. Le contenu de cet ensemble est complexe, ce qui nécessite de ne pas faire de modifications sans avoir sauvegardé au préalable ces fichiers. Ceci est très important, car en cas de modifications sans contrôle d’un de ces fichiers, des dysfonctionnements au niveau de l’affichage peuvent apparaître et provoquer des situations très problématiques où il sera extrêmement difficile de remonter les changements qui ont été effectués. La prudence est donc une vertu essentielle...

6

PowerShell et la sécurité

La sécurité est une composante essentielle de l’écosystème de PowerShell. En effet, il y a eu par le passé avec VBScript d’énormes failles de sécurité qui ont facilité l’apparition de certains virus et autres programmes malveillants dans les années 1999 et 2000. Cela a conduit Microsoft à repenser sa politique de sécurité concernant certaines des technologies que la firme met en avant.

Dans ce chapitre, nous commencerons par nous familiariser avec les stratégies d’exécution pouvant être mises en œuvre dans PowerShell. Puis nous verrons comment obtenir un certificat numérique qui nous permettra de signer nos scripts.

SOMMAIRE

Les stratégies d’exécution

Obtenir un certificat pour signer les scripts

Signer numériquement des scripts

Les stratégies d’exécution PowerShell

Une stratégie d’exécution constitue une règle de base à partir de laquelle PowerShell exécute les scripts. Toutefois, cette règle de base peut aisément être contournée, car le but n’est pas de faire de PowerShell un antivirus, mais d’établir, à partir de ces stratégies, un certain nombre de principes de sécurité.

Fonctionnement des stratégies d’exécution

Une stratégie d’exécution a un mode de fonctionnement particulier selon le contexte dans lequel elle est définie. En fonction de la cible sur laquelle elle s’applique, sa configuration résidera dans un endroit différent.

• Un utilisateur particulier

La configuration est stockée dans la base de registres.

• Un ordinateur local

La configuration est également stockée dans la base de registres.

• Une session particulière

La configuration est stockée en mémoire, ce qui implique son effacement lors de la fermeture de session.

• Un domaine

La configuration est stockée dans l’Active Directory.

De plus, elle peut affecter plusieurs types d’étendues.

• Le processus PowerShell

La stratégie d’exécution affecte uniquement la session en cours d’exécution. Dans ce cas, la valeur est Process.

• L’utilisateur actuel

La stratégie d’exécution influe sur l’utilisateur actuel. Dans ce cas, la valeur est CurrentUser.

• L’ordinateur local

La stratégie...

7

Les variables

L’utilisation des variables est peut-être la chose la plus partagée dans le monde de la programmation. En effet, elles symbolisent une multitude de types de valeurs qui sont susceptibles de changer au cours de l’exécution du programme. Et c’est là où réside d’ailleurs tout l’intérêt des variables : à un symbole particulier peuvent correspondre des valeurs qui ne sont pas figées dans le temps. Toutefois, la manifestation et l’utilisation d’une variable changent d’un langage à un autre et PowerShell n’échappe pas à cette règle.

Nous tenterons donc de définir ce qu’est une variable à partir du matériau qu’est PowerShell. Sur la base de cette compréhension, nous explorerons les différents types qu’elles peuvent revêtir.

SOMMAIRE

Comprendre les variables

Les variables d’environnement

Les variables automatiques

Les variables de préférence

Définir ce qu’est une variable

Une variable est un emplacement mémoire identifié par un nom et dans lequel des valeurs sont stockées, qui peuvent être des résultats d’expressions, des chaînes de caractères, des nombres, etc.

En PowerShell, on désigne les variables par des chaînes de caractères commençant par le symbole dollar $. La définition d’une variable donne ceci :

Création d’une variable

$<Nom_Variable> = <Valeur_Variable>;

Contrairement à certains langages de programmation comme le C, il n’est pas nécessaire de déclarer la variable avant de l’utiliser. L’initialisation se fait donc au moment de sa création :

PS> $VarNum = 19;

PS> $VarNum

19

PS> $VarStr = 'Blue'

PS> $VarStr

Blue

PS> $VarProcs = Get-Process | Where-Object {$_.ProcessName -eq 'svchost'}

PS> $VarProcs

Ces exemples illustrent la pluralité des types rencontrés. Une variable peut en effet contenir n’importe quel type de données, contrairement à des langages comme VBScript où les valeurs ne sont constituées que de chaînes. Le nom d’une variable est...

8

Les opérateurs

PowerShell dispose d’un grand nombre d’opérateurs, éléments de langage servant à manipuler des valeurs. Ils peuvent être utilisés dans des contextes différents, que ce soit en mode console ou en mode scripting. Ils ont également la capacité de s’adapter à de multiples types d’objets.

Dans ce chapitre, nous étudierons les différents types d’opérateurs pris en charge par PowerShell : d’abord les opérateurs arithmétiques pour calculer des valeurs, puis les opérateurs logiques pour complexifier les filtres d’objets. Ensuite, nous comparerons des valeurs avec les opérateurs de comparaison, affecterons des valeurs aux variables avec les opérateurs d’affectation, redirigerons d’autres valeurs vers des fichiers texte avec les opérateurs de redirection, parlerons des opérateurs split et join, identifierons les types d’objets via les opérateurs de type et, enfin, nous nous intéresserons aux opérateurs spéciaux.

SOMMAIRE

Les opérateurs arithmétiques

Les opérateurs logiques

Les opérateurs de comparaison

Les opérateurs d’affectation

Les opérateurs de redirection

Les opérateurs de fractionnement et de jointure

Les opérateurs de type

Les opérateurs spéciaux

Les opérateurs arithmétiques

Les opérateurs arithmétiques sont utiles pour calculer des valeurs numériques pouvant servir à l’exécution d’une ligne de commande ou d’un script. Il est possible d’ajouter, diviser, multiplier ou soustraire des valeurs. Le tableau suivant illustre l’ensemble des opérateurs arithmétiques pris en charge par PowerShell.

Tableau 8–1 Opérateurs arithmétiques dans PowerShell

Opérateur | Description
+ | Ajoute des entiers. Peut aussi concaténer des chaînes, des tableaux et des tables de hachage.
/ | Divise deux valeurs.
* | Multiplie des entiers. Peut aussi copier des chaînes et des tableaux.
- | Soustrait une valeur d’une autre valeur. Peut aussi convertir un nombre en nombre négatif.
% | Renvoie comme résultat le reste d’une division.

Voici quelques exemples d’utilisation de ces opérateurs de base :

PS> 2+2

4

PS> 81/9

9

PS> 7*7

49

PS> 19-10

9

PS> 10%3

1

PS> 'Windows ' + 'PowerShell'

Windows PowerShell

PS> 's' * 7

sssssss

Classiquement, ces opérateurs arithmétiques sont soumis à un ordre de précédence. PowerShell les traite dans l’ordre qui suit :

1 Les expressions à l’intérieur de parenthèses ().

2 - pour tout ce qui concerne les nombres négatifs.

3 *, / et %.

4 + et - en ce qui concerne respectivement les additions et les soustractions.

À SAVOIR Concernant la précédence des opérateurs

PowerShell traite toujours les expressions entre parenthèses () en premier, et ce, quelles que soient les modalités.

Les exemples suivants illustrent comment s’appliquent les règles de précédence :

PS> 10+20/4*2

20

PS> 10+20/(4*2)

12,5

PS> (5*5)/(5*1)

5

PS> -(10+9)

-19

Les opérations arithmétiques s’exécutent aussi sur des objets de types différents. PowerShell détermine simplement l’opération à partir du type de l’objet situé le plus à gauche dans l’opération :

PS> 'Windows' + 7

Windows7

PS> 'Windows' * 2

WindowsWindows

PS> $var1 = "C:\"

PS> $var2 = "Devel\Sources"

PS> $var1 + $var2

C:\Devel\Sources

Les opérateurs arithmétiques + et – sont aussi utilisés pour incrémenter et décrémenter des valeurs en lien avec les variables et propriétés d’objets. Dans ce cas précis, il faut plutôt parler d’opérateurs unaires (voir section sur les opérateurs d’affectation) :

PS> $num = 2

PS> $num++

PS> $num

3

PS> $num = 8

PS> $num--

PS> $num

7

Ces opérateurs sont très puissants tant les capacités de polymorphisme sont grandes.

Les opérateurs logiques

Avec PowerShell, il est possible de connecter des instructions conditionnelles afin de créer des filtres d’objets plus complexes. La possibilité de connecter des instructions les unes avec les autres donne la capacité...

9

Les tableaux et dictionnaires

Manipuler des collections d’objets est récurrent lorsque l’on utilise PowerShell. Une collection, qui est par définition un groupe d’objets de même type ou non, est par essence une structure extrêmement flexible, que l’utilisateur sera amené à utiliser aussi bien en mode console qu’en mode scripting. L’objectif de ce chapitre est de se familiariser avec les différents types de collections que l’on peut trouver dans PowerShell : les tableaux et les dictionnaires.

SOMMAIRE

Les tableaux

Les dictionnaires

Les tableaux

Un tableau est une structure de données plus ou moins complexe capable de stocker des données qui ne sont pas forcément du même type. On peut donc concevoir un tableau comme une sorte de conteneur de valeurs ou d’objets.

Créer un tableau

Créer un tableau avec PowerShell est très simple : il suffit d’affecter plusieurs valeurs à une variable. Par exemple :

PS> $Tableau = 1,2,3,4,5

Ici, la variable $Tableau contient cinq valeurs numériques. Si l’on exécute cette variable, voici le résultat produit :

PS> $Tableau

1

2

3

4

5

Il est aussi possible d’utiliser l’opérateur de plage (..) pour initialiser un tableau :

PS> $Tableau = 1..5

PS> $Tableau

1

2

3

4

5

Le tableau que nous venons de créer n’a pas de type spécifique, ce que nous pouvons vérifier avec cette ligne de commande :

PS> $Tableau.GetType()

IsPublic | IsSerial | Name | BaseType
-------- | -------- | ---- | --------
True | True | Object[] | System.Array

La colonne Name...

10

Les boucles

Il est parfois nécessaire de réaliser une opération un certain nombre de fois, même si les modalités d’action sont souvent différentes selon les objectifs recherchés. La meilleure alternative, dans ce cas précis, est d’opter pour les boucles. PowerShell offre la possibilité d’effectuer de plusieurs façons ce genre d’actions répétées.

Dans ce chapitre, nous étudierons toutes les formes de boucles que l’on peut trouver dans PowerShell, mais qui existent dans d’autres langages : les boucles for, foreach, do..while, do..until et while.

SOMMAIRE

for

foreach

do..while

do..until

while

La boucle for

La forme de boucle la plus classique est l’instruction for. Elle exécute une ou plusieurs instruction(s) tant qu’une condition particulière prend la valeur true, c’est-à-dire tant qu’elle est vraie. Dans l’immense majorité des cas, la boucle for sera utilisée pour parcourir un ensemble de valeurs, comme un tableau, dans l’objectif de traiter tout ou partie de ces valeurs.

Syntaxe de la boucle for

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

{

<liste d’instructions>

}

Tout d’abord, on initialise une variable via une valeur de départ, qui servira de valeur de référence dans l’évaluation de la condition , qui se résout en valeur booléenne true ou false. Tant que la condition est vraie, le bloc représentant la liste d’instructions s’exécutera de nouveau. Pour définir une limitation dans le processus d’exécution, il est possible de modifier la valeur de référence à chaque répétition par un...

11

Les instructions conditionnelles

Les instructions conditionnelles servent à exécuter une ou plusieurs instruction(s) uniquement si une condition particulière est remplie.

Nous commencerons par étudier l’instruction if..else, qui n’exécute pas le même bloc d’instructions selon que la condition est remplie ou non. Ensuite, nous explorerons l’instruction if..elseif..else qui a un fonctionnement similaire, mais propose plusieurs conditions. Enfin, nous nous intéresserons à l’instruction switch, plus adaptée que la précédente lorsque les conditions sont nombreuses.

SOMMAIRE

if..else

if..elseif..else

switch

L’instruction conditionnelle if..else

L’instruction if..else est utilisée dans des logiques d’orientation du code vers des chemins différents. Le principe est le suivant : si une condition particulière est évaluée à la valeur true, alors une liste d’instructions sera exécutée et PowerShell quittera l’instruction. Dans le cas contraire , c’est un autre bloc d’instructions qui sera déroulé. La condition peut être n’importe quel type d’expression renvoyant comme résultat une valeur booléenne (true ou false).

Syntaxe de l’instruction if..else

if (<expression conditionnelle>)

{

<liste d’instructions>

}

[else

{

<liste d’instructions>

}]

NOTE Sur le mot-clé else

Le mot-clé else n’est pas obligatoire. Dans ce cas, il n’y a pas de comportement « par défaut », mais seulement des instructions à exécuter lorsque la condition est vraie.

Voici un exemple simple...

12

Les fonctions

Dans ce chapitre, nous allons étudier un élément fondamental de PowerShell en tant que shell, mais aussi en tant que langage : les fonctions. En effet, dans le monde de PowerShell, elles sont considérées comme des commandes à part entière, au même titre que les scripts, cmdlets et même les commandes natives Windows. De plus, les fonctions sont aussi des passerelles vers la création de modules.

Nous commencerons donc par définir les fonctions et leur véritable valeur ajoutée en termes de programmation, pour ensuite étudier la syntaxe et comment les documenter. Enfin, nous aborderons les fonctions avancées dont la connaissance est fondamentale, car elles permettent d’écrire des cmdlets sans avoir besoin d’un langage .NET, comme C# ou Visual Basic .NET.

SOMMAIRE

Comprendre les fonctions

La syntaxe d’une fonction dans le détail

Documenter une fonction

Les fonctions avancées

Comprendre les fonctions

Une fonction est une série d’instructions identifiée par un nom, qui pourra être appelée à plusieurs reprises au cours de l’exécution d’un programme en mémoire.

En général, lorsqu’une fonction est définie, elle renvoie une valeur qui peut être affichée directement en sortie d’écran, affectée à une variable, mais aussi utilisée au sein d’autres fonctions. Avec PowerShell, les fonctions sont riches et extrêmement souples, et elles sont aussi bien écrites de manière simple avec une syntaxe aisément compréhensible, que de manière beaucoup plus complexe.

Déclarer une fonction

Voici un exemple d’une fonction très sommaire :

Déclaration d’une simple fonction

function Simple-fonction {

Write-Host "Ceci est une simple fonction."

}

Pour la déclaration, il suffit d’utiliser le mot-clé function , suivi du nom à donner à notre nouvelle fonction, Simple-fonction . Les accolades {} servent à circonscrire le bloc de code à exécuter. Les fonctions sont construites comme les blocs de script, à la différence qu’elles ont un nom ; en réalité, ces derniers ne sont autres que des fonctions anonymes ou lambda.

Si nous exécutons cette fonction dans un shell, voici ce que nous obtenons :

PS> Simple-fonction

Ceci est une simple fonction.

Donc, en PowerShell, une fonction la plus simple possible a le format suivant.

Structure fondamentale d’une fonction

function <nom de la fonction> {instructions}

Il est fortement recommandé de suivre les règles de nommage qui touchent toutes les commandes PowerShell : une paire verbe-nom où :

• le verbe représente une action à mener par la fonction ;

• le nom représente l’élément visé par l’action.

Bien construit, le nom d’une fonction a la même structure que celui d’une cmdlet. L’utilisateur ne fait pas la différence entre les deux types de commandes, contrairement à PowerShell. Toutefois, nous pouvons utiliser la ligne de commande suivante pour savoir à quel type on a affaire :

PS> get-command Simple-fonction | Select-Object -Property CommandType, Name

CommandType | Name
----------- | ----
Function | Simple-fonction

...

13

Les modules

Une question que nous n’avons pas encore posée est celle de la réutilisation du code. En effet, un code fréquemment utilisé doit être encapsulé dans un package, ou dans un module, pour éviter de le réécrire plusieurs fois. La question de la réutilisation du code pose un certain nombre de problèmes quasi épistémologiques que nous n’aborderons pas dans ce livre. Cependant, réutiliser du code en provenance d’une autre source est un phénomène très répandu, mais malheureusement mal compris.

Dans ce chapitre, nous définirons ce qu’est un module PowerShell. Ensuite, nous apprendrons à en construire, opération indispensable pour qui veut créer des extensions. Enfin, nous évoquerons succinctement les PSSnapins, qui représentent en quelque sorte l’ancien modèle en termes d’extensions PowerShell.

SOMMAIRE

Qu’est-ce qu’un module PowerShell ?

Créer un module

Un mot sur les PSSnapins

15

L’infrastructure WMI et CIM

PowerShell fait preuve de cohérence, jusque dans les composants qu’il utilise, comme WMI (Windows Management Instrumentation). WMI est apparu à une époque où l’administration des composants reposait sur des axes multiples et où le besoin d’homogénéisation se faisait croissant. Depuis ses débuts, PowerShell fournit une abstraction importante pour utiliser WMI. Cette abstraction autorise une certaine simplicité que l’on ne retrouve évidemment pas dans d’autres langages comme C++ ou Visual Basic .NET.

Nous commencerons dans ce chapitre par nous familiariser avec le concept WMI et ce qu’il implique. Puis nous explorerons les possibilités offertes par PowerShell en matière de collecte et de manipulation de données via WMI, pour enfin nous tourner vers les cmdlets CIM (Common Information Model) représentant une voie vers laquelle les utilisateurs devront progressivement s’orienter.

SOMMAIRE

Définir ce qu’est WMI

Utiliser WMI

Utiliser les cmdlets CIM