Bonjour à tous.
J’ai créé ce blog afin de partager mes connaissances acquises,mes astuces et les problèmes rencontrés depuis le début de ma carrière dans le métier. Ce blog n’a pas pour but d’être un support de formation mais simplement un partage de connaissances.J’espère que d’autres personnes auront envie de rebondir sur mes articles et d’apporter leur pierre à l’édifice
Si vous êtes du métier depuis quelques années déjà, vous avez sûrement déjà entendu parler de cette bête-là. Peut-être que vous l’utilisez déjà à outrance et c’est ce que je vous souhaite 🙂
Alors pour les néophytes, qu’est-ce que PowerShell ? Et bien, c’est un langage de script et un interpréteur de commandes. Il s’appuie sur le langage .NET Framework et est donc de ce fait, plutôt orienté objet. Il est très en vogue désormais et quasi tous les logiciels Microsoft récents sortent avec une interface PowerShell appelé « Module » afin de pouvoir automatiser des tâches d’exploitation du produit. Parmi les divers outils pouvant être « pilotés » en PowerShell, on retrouvera:
Vu que la plupart des infrastructures informatiques des sociétés contiennent un ou plusieurs de ces outils, il peut donc être intéressant de ce pencher sur ce langage.
Je réaliserai plusieurs articles sur le sujet prochainement afin de soit vous mettre le pied à l’étrier ou bien d’approfondir vos connaissances pour ceux qui maîtrisent déjà le sujet.
Vous avez décidé de vous y mettre? Il y a 2 outils sous Windows permettant d’écrire du code Powershell:
L’invite de commande sera plutôt utilisée pour exécuter une seule ligne de code ou un script tandis que l’ISE servira à rédiger des scripts plus importants.
Sur un Système d’Exploitation client ( Win 7,8,10).Vous pouvez y accéder en recherchant dans la barre Windows:
Sur les Os serveur pré Windows 2012, l’invite de commande est également native. En revanche, pour l’ISE, il sera à ajouter par l’ajout de fonctionnalité Windows Server.
Vous êtes à présent fin prêt pour commencer à coder en PowerShell 🙂
Maintenant que vous savez comment accéder à PowerShell, nous allons écrire notre premier script. Ouvrez le logiciel ISE et copiez-collez le code suivant:
#Ceci est un commentaire
$Texte="Hello World !"
Write-host $Texte
Décortiquons ce script; la première ligne est simplement un commentaire. C’est le caractère # qui permet de commenter son code afin qu’il soit compréhensible par d’autres personnes que l’auteur. On reconnaît facilement un commentaire par sa couleur verte.
Ensuite nous instancions une variable String nommée Texte et y plaçons « Hello World ». Contrairement à certains autres langages, il n’est pas obligatoire de « CASTER » ses variables, c’est à dire que la variable prendra automatiquement le bon type en fonction de ce que l’on place après le signe « = »
Exemples:
$Texte = « abc » sera une variable String
$Nombre = 12 sera une variable Integer
$Pays = « France »,« Belgique »,« Allemagne » sera un tableau de String
Enfin la ligne Write-Host permet d’afficher le contenu de la variable $Texte à l’écran. On peut comparer cette commande au bon vieux « Echo » en batch.
Nous allons désormais sauvegarder le contenu de notre script dans un fichier. Pour ce faire, faites « Enregistrer sous.. », nommez le « HelloWorld » et choisissez un emplacement pour votre premier script PowerShell. Ce dernier aura l’extension .ps1.
Ouvrez l’invite de commande PowerShell (en mode administrateur), placez-vous dans le dossier où se trouve le script (avec CD, comme en batch. nous verrons la méthode PowerShell dans un prochain article, soyez patient :)). Pour exécuter le script, tapez la commande suivante :
.\HelloWorld.ps1
Et là.., c’est le drame, vous obtenez joli message d’erreur rouge flamboyant, vous disant
que vous n’avez pas le droit d’exécuter du code PowerShell:
Zut alors, nous étions si près du but. Je vous rassure. Rien d’irrémédiable dans ce petit souci. Cela me permet de vous introduire une notion important dans PowerShell, les niveaux d’exécution. Il existe 5 niveaux de sécurité configurable en PowerShell, ci-dessous un résumé de chacun d’entre eux:
-Niveau par défaut sur un Windows 7,8,10
-Autorise l’exécution de commandes isolées mais pas de scripts
-Autorise l’exécution de script uniquement s’ils sont signés numériquement
-Autorise l’exécution de script localement. C’est le niveau par défaut sur un Windows Server 2012 R2
-Nécessite que les scripts venant de l’extérieur (Internet, etc.) soient signés numériquement
-Autorise l’exécution de tout script. Il y aura juste un avertissement si le script vient d’internet.
-Aucuns avertissements de sécurité, tous les scripts sont autorisés.
Après cette petite introduction, revenons-en à notre premier script. Afin de pouvoir l’exécuter, nous allons changer le niveau de sécurité d’exécution de notre machine locale pour se mettre dans le mode « RemoteSigned ». Pour ce faire, tapons la commande suivante:
Set-ExecutionPolicy -ExecutionPolicy RemoteSigned
Il vous est demandé de confirmer que vous voulez changer de stratégie d’exécution, Tapez « O ». Vous pouvez vérifier que votre niveau a bien changé à l’aide de la commande :
Get-ExecutionPolicy
qui doit vous renvoyer « RemoteSigned ». Voilà, nous pouvons désormais tenter à nouveau d’exécuter le script « HelloWorld.ps1 »:
et là miracle, cela fonctionne :
Alors, fier de vous? Vous pouvez, c’est un bon début. Dans un prochain article, nous allons nous pencher sur l’utilisation des commandes PowerShell (appelées CmdLet) les plus utilisées.
Vous voulez en savoir plus sur le langage PowerShell ? Vous préférez apprendre en vidéo? J’ai créé un contenu Udemy pour les débutants. C’est par ici :
https://www.udemy.com/course/powershell-initiation-a-loutil-et-guide-pour-bien-debuter/
Dans le dernier article, nous avions écrit notre premier script ensemble qui affichait une phrase à l’écran. Nous avons pour cela utiliser la commande :
Write-Host $Texte
Voici donc un bon exemple pour vous introduire une notion du PowerShell ,c’est à dire les Cmdlet ! Une Cmdlet est un script natif dans PowerShell et qui exécute une fonction particulière. Elle sera toujours composée d’un verbe et d’un nom. Elle peuvent être majoritairement triées en 2 grandes familles: Les Cmdlets qui récupèrent de l’information (elles seront souvent préfixées du verbe « GET » et les Cmdlets qui mettent à jour le système et qui porteront le préfixe « SET ». Il existe une multitude de Cmdlet et le chiffre croit à chaque mise à jour du composant. Par exemple, en PowerShell 5 (version fournie avec Windows 10 et Windows Server 2016), il existe 1286 Cmdlets différentes.
Vous allez me dire… mais comment les apprendre et connaître leurs paramètres par cœur? Et bien je vous rassure tout de suite, il n’y nul besoin de remplir son cerveau de ces commandes car PowerShell fournit une aide très complète sur chacune d’entres elles.
Pour accéder à l’aide , il suffit de placer la commande Get-Help devant la commande pour laquelle vous souhaitez de l’aide. Tout de suite un exemple :
Get-Help Get-Service
Get-Service est une commande permettant d’afficher les services du système d’exploitation. Regardons comme elle s’utilise:
Tout d’abord, si vous êtes sur un système d’exploitation récent, l’aide de PowerShell n’est plus nativement disponible hors-ligne. A la première demande d’aide, PowerShell vous proposera de se connecter à internet afin de rapatrier les fichiers d’aide. Répondez donc Oui à la question. Après quelques instants vous verrez apparaître ceci :
Il y est expliqué la fonction de la commande, sa syntaxe, le type de paramètre attendu.
Il existe également la possibilité de faire apparaître des exemples ce qui me semble souvent être plus parlant que simplement lire les paramètres de la syntaxe:
Pour ce faire, tapez:
Get-Help Get-Service -examples
Vous verrez alors une série d’exemple incorporant des cas concrets:
Dans l’exemple ci-dessus, la commande affichera tous les services dont le statut actuel est « démarré ». Vous n’êtes pas encore en mesure de comprendre complètement cet exemple vu que la syntaxe utilisée ne vous est pas encore familière. J’y reviendrai plus tard.
Je vous laisse dès à présent prendre connaissance de cette intéressante fonctionnalité et vous dit, à la prochaine !
Dans les prochains articles, nous aborderons la syntaxe d’un script, l’initialisation d’objets, la manipulation de ceux-ci (par l’accès aux méthode et aux propriétés) et le pipe « | ».
Bonjour à tous,
je reviens aujourd’hui avec un article sur la manipulation d’objet et l’utilisation très précieuse du pipe en PowerShell.Le pipe est une technique permettant d’agir sur un objet en vue de s’en servir dans une seconde action. Cela permet entre autre de filtrer le nombre de propriétés affichées selon des critères précis, de mettre en forme un objet (par exemple sous la forme de liste ou de tableau) mais également d’effectuer une action sur celui-ci (Exemple, pour un service ayant un certain nom, le stopper).
J’aimerais avant tout revenir sur le fait que PowerShell est un langage de scripting orienté Objet. C’est à dire que toute variable instanciée est un objet. Faisons une petite parenthèse sur la programmation orienté objet pour se familiariser avec le concept.
En programmation orientée objet (ou POO), on appelera objet une entité ayant des propriétés et des méthodes.
Pour le coup, vous n’êtes pas plus avancé 😀 , on va donc prendre un bête exemple:
Si l’on parle d’un objet de type « Personne », ses proriétés seraient par exemple:
En ce qui concerne ses méthodes (au sens POO du terme), cela serait plutôt :
Fin de parenthèse, revenons à PowerShell avec un exemple concret de manipulation d’un objet.
Ouvrez votre console préférée (quoi ?! ce n’est pas encore le cas? Cela va venir!) j’ai nommé Windows PowerShell. Et copiez-collez la commande suivante :
$ServiceWU=Get-Service -DisplayName ‘Windows Update’
Décortiquons cette ligne de code. Nous demandons à la console d’afficher le service Windows Update et nous le plaçons dans une variable (ou un objet) qu’on appelle ServiceWU.
Si l’on affiche cette variable avec la commande suivante:
$ServiceWU
l’on voit apparaitre diverses informations sur ce service:
Son statut (arrêté dans notre cas), le nom ( qui est le nom de l’exécutable associé au service) et enfin le nom d’affichage tel qu’on peut le trouver dans la console de gestion des services.
Ces 3 informations sont donc des « PROPRIETES » de l’objet service (Nous y voilà).
Il existe également des méthodes associées à cet objet de type service. Comme vous pouvez vous en douter, on retrouvera parmi les méthodes:
Pour un objet un donné ici $ServiceWU, il est possible de lister toutes les propriétés et les méthodes disponibles avec la commande suivante:
$ServiceWU | Get-Member
Je profite de cette commande pour expliquer l’utilisation du pipe .Vous devez interpreter cette dernière comme étant « Pour le service Windows Update contenu dans la variable ServiceWU, affiche-moi toutes ses propriétés/méthodes.Je redirige donc toutes les informations contenues dans ma variable $ServiceWu à la cmdlet Get-Member »
Le résultat donne ceci:
Comment les utiliser? C’est simple. Pour afficher une propriété donnée, on appliquera un . + le nom de la propriété derrière l’objet. Par exemple si l’on désire connaitre les dépendances de notre service Windows Update l’on tapera la commande :
$ServiceWU.RequiredServices
Ce qui nous affichera ceci:
Si l’on veut utiliser une méthode d’un objet, l’on appliquera également un . + le nom de la méthode mais on y ajoutera 2 parenthèses vides (dans le cas d’une méthode où il n’y a pas de paramètres). Pour démarrer notre service Windows Update placé dans la variable $ServiceWU l’on mettra:
$ServiceWU.Start()
L’on aurait pu également invoquer la méthode Start en « pipant » la variable ServiceWU à une autre cmdlet permettant de piloter les services nommé « Start Service » de cette manière:
$ServiceWU | Start-Service
et c’est ainsi que se referme cet article sur l’introduction au Pipe et manipulation des objets en PowerShell. A la prochaine !
Bonjour à tous, aujourd’hui nous allons apprendre à réaliser une boucle sur un objet de type tableau (contenant donc plusieurs objets) en vue de réaliser la même action sur chacun d’entre eux et le tout, avec notre langage préféré.
Gné ? Quoi de mieux qu’un bon exemple ludique pour appréhender le concept.
Admettons hypothétiquement que nous téléchargions sur un site tout à fait légal, du contenu audio :D. La majorité du temps à la fin de notre absolument non-frauduleuse action, nous nous retrouvons avec des mp3 qui se nomme:
Quoi de plus énervant pour le classer… remédions à cela en ôtant tout ce qui se trouve entre crochet. Pour ce faire, nous allons écrire un script qui parcourra le dossier où les MP3 se trouvent, qui instanciera une variable avec ses derniers. Il restera ensuite à réaliser une boucle sur les éléments du dossier et enfin pour chacun des éléments, réaliser un renommage du fichier pour enlever tout ce qui nous ennuie. Le script allant être composer d’une dizaine de lignes, je vous propose de le rédiger avec l’ISE. Je vais expliquer en pas à pas les différentes étapes du script et je les rassemblerai pour vous donner le script complet à la fin de cet article.
Premièrement, comme nous avons placé nos fichiers MP3 dans un dossier (c:\temp dans l’exemple) avec du contenu hétéroclite (waouh le beau mot), il va falloir filter l’extension de notre dossier afin de n’avoir que nos MP3 dans la variable sur laquelle nous allons boucler.
C’est avec la commande Get-ChildItem que nous allons réaliser cette opération:
$File_To_Rename=Get-ChildItem -path C:\temp\* -Include *.mp3
Cette ligne de code signifie simplement que nous cherchons dans le chemin c:\temp tout ce qui se termine par .mp3 et nous plaçons cette information dans une variable File_To_Rename.
Si l’on affiche notre variable en tapant son nom (avec le dollar) dans la console, l’on voit bien les fichiers répondant à notre critère:
Il ne nous reste plus qu’à boucler sur les 3 éléments afin de les renommer. Il existe plusieurs sortes de boucles différentes. le Do… While, le While…Do et celle que nous allons utiliser, le Foreach. Voici sa syntaxe appliquée à notre exemple. Pour boucler sur les éléments de la variable File_To_Rename, voici comment faire:
Foreach ($element in $File_To_Rename) {
# CE QUE L’ON VEUT FAIRE SUR CHACUN DES OBJETS
}
La syntaxe du foreach est la suivante, on commence par écrire le mot Foreach puis on place entre parenthèses la condition qui va définir le nombre de fois que l’on va boucler. Ici nous avons choisi de boucler sur le nom d’éléments dans la variable File_To_Rename. La variable $element n’existe nulle part, vous auriez pu mettre $ ce que vous voulez, c’est juste la variable qui permettra de se référer à l’objet courant pour la boucle. Une fois la condition établie, on placera entre accolades le code à exécuter pour chaque élément de la variable de boucle. Il va s’agir ici d’effectuer un renommage du nom du fichier en enlevant ce qui est placé entre crochet. Ci-dessous la commande pour réaliser le renommage:
$NewName=$element.Name -replace « \[ http://www.sitelegal.com \] », » »
Rename-Item -LiteralPath $element -NewName $NewName
Attention, ça se corse un peu ( mais on ne va pas abandonner en si bon chemin !) .
Premièrement, nous initialisons une variable NewName dans laquelle nous modifions la propriété Name de l’élément courant (souvenez-vous la boucle passe sur chaque fichier portant l’extension mp3) pour remplacer [www.sitelegal.com] par rien. Nous avons dû avoir recours à l’échappement de nos crochets pour qu’il soit bien compris comme un caractère et non comme une syntaxe.Nous nous servons ensuite de la cmdlet Rename-Item qui comme son nom l’indique permet de renommer un élément.Elle aussi n’aime pas beaucoup les caractères réservés, c’est pour quoi il est obligatoire de placer le paramètre « literalPath » au lieu du « path » classique pour que le caractère [] ne soit pas interprété.
Nous voilà donc avec un script complet qui doit ressembler à ceci:
$File_To_Rename=Get-ChildItem -path C:\temp\* -Include *.mp3
Foreach ($element in $File_To_Rename) {
$NewName=$element.Name -replace « \[www.sitelegal.com\] », » »
Rename-Item -LiteralPath $element -NewName $NewName
}
et voici le résultat après le renommage:
Tadaaaam ! Alors, on commence à sentir l’intérêt du langage? Vous avez des idées de script qui vous viennent à l’esprit? Tant mieux.
Sur ce, au revoir et à la prochaine pour une nouvel article 😀
Vous aimez les astuces ? Venez découvrir 5 Astuces Powershell que vous ne connaissez probablement pas :
Vous voulez en savoir plus sur le langage PowerShell ? Vous préférez apprendre en vidéo? J’ai créé un contenu Udemy pour les débutants. C’est par ici :
https://www.udemy.com/course/powershell-initiation-a-loutil-et-guide-pour-bien-debuter/
Bonjour à tous,
Je viens vers vous avec une nouvel article sur une cmdlet très utile en PowerShell : Get-WmiObject. Comme son nom l’indique, cette commande permet de récupérer et ou de piloter des objets WMI. Tout d’abord, afin qu’on se comprenne, un petit rappel sur ce qu’est le WMI. C’est une interface de gestion des éléments logiques et physiques de l’ordinateur sous Windows. Cela s’appuie sur le modèle de données CIM qui est un standard ouvert de gestion des composants des systèmes d’informations. Comme un bon exemple se substitue souvent à un long discours, lançons-nous dans l’utilisation de la cmdlet afin d’obtenir des informations sur le système d’exploitation. Il faut tout d’abord savoir que le WMI est composé de plusieurs espaces de nom (NAMESPACE en anglais) et que pour chacun d’entres eux, il existe plusieurs classes. Dans ces classes il y a des propriétés et des méthodes (à dis donc ça me rappelle quelque chose, un précédent article peut-être). Prenons la classe listant les volumes de la machine : Win32_LogicalDisk
Voici comment lister le contenu de cette classe en PowerShell :
Get-WmiObject -class Win32_LogicalDisk
Simple me direz-vous? Effectivement, pourvu que l’on connaissance la classe correspondant à l’information voulue. Pour ce faire, il existe des logiciels permettant de lister relativement simplement les classes et leurs contenus. Je vous conseille celui-ci nommé WMI Explorer : http://wmie.codeplex.com/.
Revenons à notre exemple et ce que la commande renvoie:
Nous voyons donc affiché le seul volume existant sur cette machine, c’est à dire le C:.
On voit également son type, 3 dans ce cas-ci. Pour savoir à quoi cela correspond, un petit tour sur MSDN va nous répondre:
Dans notre cas, le disque C: est un disque local. S’il y avait eu une clé usb branchée, cela aurait été un type 2 etc.
Les autres valeurs affichées sont l’espace libre, la taille totale et le cas échéant le nom du volume. Comme vous pouvez le remarquer, les valeurs de taille sont écrites en octets et non en Méga-Octets ou Giga-Octets comme cela serait le plus censé. Qu’à cela ne tienne, je vais vous montrer une petite astuce pour modifier la sortie de la commande afin d’effectuer directement des calculs sur les valeurs renvoyées. Nous allons afficher la taille totale et l’espace libre en Go pour que cela soit plus lisible. Pour modifier l’affichage, nous allons nous servir de notre | « pipe ». Je vais vous écrire la syntaxe pour la commande finale, puis je vous l’expliquerai. Attention, ça va piquer les yeux.
Get-WmiObject -Class Win32_LogicalDisk | Select-Object DeviceID,@{Name=« FreeSpace »;Expression={« {0:N2} » -f ($_.FreeSpace/1GB)}},@{Name=« TotalSpace »;Expression={« {0:N2} » -f ($_.Size/1GB)}}
Je vous conseille de la copier-coller dans l’ISE pour l’afficher sur une seule ligne pour plus de lisibilité. Elle peut être séparée en 2 grandes parties. Ce qui se trouve à gauche du pipe qui va rapatrier l’informations et ce qui est à droite du pipe qui va se charger de réaliser l’affichage que nous voulons. Comme je le disais plus haut, la commande native Get-WmiObject sur la classe Win32_LogicalDisk affichait les valeurs de taille et d’espace libre de manière brute en octets. La partie droite du pipe va donc « formater » ces chiffres pour les afficher d’une part en Gigas et avec 2 virgules. Décortiquons là:
Get-WmiObject -Class Win32_LogicalDisk
Cette partie a déjà été décrite plus haut. En résumé, on instancie un objet de type WMI en y intégrant le contenu de la classe Win32_LogicalDisk. Cette dernière contient les informations sur les disques logiques (volumes,partitions) du poste de travail.
| Select-Object DeviceID,@{Name=« FreeSpace »;Expression={« {0:N2} » -f ($_.FreeSpace/1GB)}},@{Name=« TotalSpace »;Expression={« {0:N2} » -f ($_.Size/1GB)}}
C’est ici que cela se complique. Du moins la syntaxe se complique car vous allez voir que le résultat n’est rien de bien complexe. On commence par le | qui permet de rediriger l’objet WMI afin de le traiter. La cmdlet Select-Object permet de choisir les propriétés de l’objet à afficher. Sans mettre cela, la cmdlet dispose d’un affichage par défaut contenant plusieurs propriétés standards.Si l’on veut réaliser un affichage personnalisé (comme dans notre exemple), on sélectionne les propriétés nécessaires. J’ai choisis d’afficher le DEVICEID qui représente la lettre. Pour les autres champs à afficher, j’utilise une syntaxe particulière permettant de réaliser des calculs, modifications de propriétés natives de l’objet. Dans notre cas, je vais effectuer une division de la propriété Espace Total et Espace Libre pour l’obtenir en Gigas. Analysons, l’affichage de l’une des 2 propriétés:
@{Name=« FreeSpace »;Expression={« {0:N2} » -f ($_.FreeSpace/1GB)}}
Il faudra commencer par entourer tout la propriété personnalisée de @{…}. Ensuite on définit un nom personnalisé à la nouvelle propriété virtuelle avec la syntaxe Name= »votrenom ». Ensuite on place un point virgule puis le mot Expression suivi d’un = . C’est ici que l’on réalisera le calcul sur la propriété.L’expression doit être placée entre accolades. Le {0:N2} -f signifie que l’on formate ce qui se trouve à droite pour n’afficher que 2 décimales. ensuite $_.FreeSpace/1GB signifie que que l’on prend la valeur de la propriété Freespace pour l’objet courant (c’est à dire 1 des disques listé par la commande Get-WmiObject) et que l’on divise la valeur pour obtenir des gigas (oui ça se fait tout seul, sans quoi on aurait dû diviser par 1024³). Le résultat final est ceci :
et voilà, une flèche de plus à votre arc. Vous avez des connaissances sur WMI et vous savez formater vos objets PowerShell comme il vous plait !
A la prochaine pour de nouvelles aventures.
Bien le bonjour et bienvenue dans ce nouvel article dans lequel je vais vous expliquer comment exécuter du code PowerShell qui se connectera à une machine à distance.
L’on peut distinguer plusieurs manière d’exécuter des cmdlets sur un système distant:
Invoke-Command -ComputerName CFG1 -ScriptBlock {
If (Get-Process -Name iexplore)
{
Write-Host « Installe-toi donc un navigateur digne de ce nom… »
}
}
Comme nous l’avons fait précédemment dans les autres articles, décortiquons ce petit script.
Le script effectue donc une connexion temporaire sur l’ordinateur CFG1 et exécute les lignes de code entourée par les accolades du paramètre ScriptBlock.
La première: If (Get-Process -Name iexplore) fait appel à ce qu’on appelle une instruction conditionnelle. En effet, le if signifie « Si » et peut être utilisé de la manière suivante:
SI ( la condition est vraie) {JE FAIS CETTE ACTION}
Dans notre exemple, l’on peut traduire cette ligne en :
SI (il existe un processus iexplore.exe lancé sur la machine) .
La seconde ligne du script réalise un affichage d’un message à l’écran SI la condition nommée dans le IF est remplie.
Voici le résultat avec un processus Internet Explorer lancé sur la machine distante:
[CFG1] Connecting to remote server CFG1 failed with the following error message : The client cannot connect to the destination specified in the request. Verify that the service on the destination is running and is accepting requests.Consult the logs and documentation for the WS-Management service running on the destination, most commonly IIS or WinRM. If the destination is the WinRM service, run the following command on the destination to analyze and configure the WinRM service: « winrm quickconfig ». For more information, see the about_Remote_Troubleshooting Help topic.
Oh, zut alors 🙂 quoi? je l’aurais fait exprès? Meuh non, c’est tout à fait fortuit.. ce message d’erreur me permet donc de vous introduire à un autre composant clé du PowerShell à distance, le protocole WinRM. Winrm pour Windows Remote Management est un applicatif de chez Microsoft basé sur le protocole générique WS-Man. C’est parce que le Winrm n’est pas configuré comme il faut sur le poste distant que nous avons reçu ce joli message d’erreur. Pour corriger ceci, 2 manières: soit en exécutant la commande winrm quickconfig dans un CMD, ou bien utiliser la cmdlet Enable-Psremoting sur l’ordinateur distant. Dans les 2 cas, les actions suivantes vont être réalisées:
Les diligences associées au Remote PowerShell étant remplies, ré-exécutons notre commande de tout à l’heure et observons cette fois-ci le résultat:
Voili, voilou. un processus iexplore a été détecté sur la machine distante et le message mentionné dans la condition IF s’est donc affiché à l’écran.
$s=New-PSSession -ComputerName CFG1
Enter-PSSession -Session $s
Je crée un objet de session PowerShell sur l’ordinateur CFG1 que je place dans la variable s puis je rentre dans cette session. L’on peut voir désormais que l’invite PowerShell est précédé de [CFG1] signifiant que je suis effectivement bien connecté sur la machine voulue. On peut le vérifier facilement en affichant par exemple la variable d’environnement « computername » pour afficher le nom de l’ordinateur sur lequel on se trouve:
L’avantage de cette méthode est que l’on peut se déconnecter de la session et y revenir plus tard. Cela permet de garder les dernières commandes introduites, les variables instanciées etc.. Pour quitter une session ouverte, l’on utilisera la commande Exit-PSsession. On pourra dès lors y revenir en tapant de nouveau « Enter-PSsession« .
Une fois le travail terminé, l’on peut refermer définitivement notre session en utilisant la commande Remove-PSSession.
Et c’est sur cette dernière méthode que se referme cet article. En espérant vous avoir intéressé, à bon entendeur Salut !
Bonjour à tous. Aujourd’hui, on va voir comment étendre l’utilisation du PowerShell en utilisant les objets COM présents dans Windows. Allez comme d’hab’, on commence par un petit récap’ de ce qu’est un objet COM. Un objet COM késako? Et bien pour faire simple, c’est un standard de chez Microsoft permettant à des programmes de communiquer ensemble par l’utilisation de méthodes et de propriétés(ça me dit quelque chose…méthodes…propriétés.. Comme la POO 🙂 ). un exemple d’utilisation? et bien les produits de la suite Office disposent d’une interface COM. Internet Explorer également/En vérité, il en existe une kyrielle. Ci-dessous la requête PowerShell permettant de les lister :
gci HKLM:\Software\Classes -ea 0| ? {$_.PSChildName -match ‘^\w+\.\w+$’ -and
(gp « $($_.PSPath)\CLSID » -ea 0)} | ft PSChildName
Dans le cadre de l’article, nous allons utilisez un objet COM très utile pour remplir des données collectées, celui de Microsoft Excel. J’ai décidé de vous montrer comment récupérer les services Windows sur l’ordinateur et de créer un fichier Excel les contenant.
Pour instancier un objet COM excel, rien de plus simple :
$ExcelObj=New-Object -ComObject Excel.Application
Et voilà, notre objet ExcelObj contient une instance d’excel. Vous pouvez le confirmer en allant dans le gestionnaire de tâches. Vous verrez un exécutable Excel qui tourne:
Par défaut, un objet com Excel,ne sera pas visible. La plupart du temps, on l’instanciera, on le remplira avec du code et à la fin du script, on rendra visible le résultat. Souvenons-nous de notre but, récupérer les services de l’ordinateur et les lister dans un fichier Excel.
En français, nous devons programmer le code suivant:
Tout d’abord,on ouvre un nouveau classeur Excel. Effectivement,en lançant un objet Excel, nous n’avons rien fait de plus qu’ouvrir le logiciel vide. Il faut faire l’équivalent de « nouveau fichier » afin de créer un classeur. Dans le classeur nous ajouterons un feuillet. On récupère ensuite la liste des services dans un objet.Après nous allons boucler sur cette objet afin de passer sur chacun d’entres eux puis l’on écrira sur 1 ligne du feuillet Excel, le nom, le nom d’affichage, le statut actuel et le type de démarrage. Puis l’on devra incrémenter la colonne de 1 et continuer ainsi de suite jusqu’au dernier service.
Créer tout d’abord notre classeur et notre feuillet :
$Classeur=$ExcelObj.Workbooks.add()
$Feuillet = $Classeur.WorkSheets.Add()
On va maintenant créer notre objet contenant tous les services:
$ServiceObj= Get-Service
Plus qu’à boucler sur cet objet et pour chacun d’entres eux remplir le fichier Excel.
On va d’abord mettre un Header sur chacunes des colonnes qui correspondra à la propriété qu’on affiche cad le nom court, le nom d’affichage, le statut.
Pour écrire dans le tableur on procède de la manière suivante:
$Feuillet.Cells.Item(1,1) = « Nom court » # on écrit « nom court » dans la colonne A1
$Feuillet.Cells.Item(1,2) = « Nom d’affichage » # « nom d’affichage » dans la colonne A2
$Feuillet.Cells.Item(1,3) = « Statut » #ETC..
Maintenant on commence à boucle sur les service, et on incrémentera l’index de ligne à la fin de chaque service afin d’écrire sur la ligne d’après:
$cpt = 2
Foreach ($Service in $ServiceObj)
{
$Service.Name = $Feuillet.Cells.Item($cpt,1)
$Service.DisplayName = $Feuillet.Cells.Item($cpt,2)
$Service.Status = $Feuillet.Cells.Item($cpt,3)
$cpt ++
}
On finit le script en rendant visible le fichier Excel.
$ExcelObj.Visible = $True
Le script est désormais terminé. Ci-dessous le résultat final :
Alors ? Heureux? Vous avez le cerveau rempli d’idées mettant en application cet article? Tant mieux ! A la prochaine.
JustAnItBlog 