PowerShell Tutoriel
Démarrer avec PowerShell

Remarques

Versions

Installation ou configuration

les fenêtres

PowerShell est inclus avec Windows Management Framework. L'installation et la configuration ne sont pas requises sur les versions modernes de Windows.

Les mises à jour de PowerShell peuvent être effectuées en installant une version plus récente de Windows Management Framework.

Autres plates-formes

La version "Beta" de PowerShell 6 peut être installée sur d'autres plates-formes. Les packages d'installation sont disponibles ici .

Par exemple, PowerShell 6, pour Ubuntu 16.04, est publié pour empaqueter les référentiels afin de faciliter l’installation (et les mises à jour).

Pour installer, procédez comme suit:

# Import the public repository GPG keys
curl https://packages.microsoft.com/keys/microsoft.asc | sudo apt-key add -

# Register the Microsoft Ubuntu repository
curl https://packages.microsoft.com/config/ubuntu/16.04/prod.list | sudo tee /etc/apt/sources.list.d/microsoft.list

# Update apt-get
sudo apt-get update

# Install PowerShell
sudo apt-get install -y powershell

# Start PowerShell
powershell

Après avoir enregistré le référentiel Microsoft en tant que superutilisateur, il vous suffit d’utiliser sudo apt-get upgrade powershell pour le mettre à jour. Alors lancez simplement powershell

Autoriser les scripts stockés sur votre machine à s'exécuter sans signature

Pour des raisons de sécurité, PowerShell est configuré par défaut pour autoriser uniquement l'exécution des scripts signés. L'exécution de la commande suivante vous permettra d'exécuter des scripts non signés (vous devez exécuter PowerShell en tant qu'administrateur pour ce faire).

Set-ExecutionPolicy RemoteSigned

Une autre façon d’exécuter des scripts PowerShell consiste à utiliser Bypass comme ExecutionPolicy :

powershell.exe -ExecutionPolicy Bypass -File "c:\MyScript.ps1"

Ou à partir de votre console PowerShell ou de votre session ISE existante en exécutant:

 Set-ExecutionPolicy Bypass Process

Une solution de contournement temporaire pour la stratégie d'exécution peut également être obtenue en exécutant le fichier exécutable Powershell et en transmettant toute stratégie valide en tant que paramètre -ExecutionPolicy . La stratégie est en vigueur uniquement pendant la durée de vie du processus, de sorte qu'aucun accès administratif au registre n'est nécessaire.

C:\>powershell -ExecutionPolicy RemoteSigned

Plusieurs autres stratégies sont disponibles et les sites en ligne vous encouragent souvent à utiliser Set-ExecutionPolicy Unrestricted . Cette stratégie reste en place jusqu'à ce qu'elle soit modifiée et diminue la position de sécurité du système. Ceci n'est pas conseillé. L'utilisation de RemoteSigned est recommandée car elle permet de stocker et d'écrire du code en local et requiert que le code acquis à distance soit signé avec un certificat provenant d'une racine approuvée.

Veillez également à ce que la stratégie d'exécution soit appliquée par la stratégie de groupe, de sorte que la stratégie de groupe, même modifiée, Unrestricted pour l'ensemble du système (généralement 15 minutes). Vous pouvez voir la stratégie d'exécution définie sur les différentes étendues à l'aide de Get-ExecutionPolicy -List

Documentation TechNet:
Set-ExecutionPolicy
about_Execution_Policies

Alias ​​et fonctions similaires

Dans PowerShell, il existe plusieurs manières d'obtenir le même résultat. Ceci peut être bien illustré avec l'exemple simple et familier de Hello World :

Utilisation de Write-Host :

Write-Host "Hello World"  

Utilisation de Write-Output :

Write-Output 'Hello world'

Il est à noter que bien que Write-Output & Write-Host écrivent tous deux sur l'écran, il y a une différence subtile. Write-Host écrit uniquement dans stdout (c.-à-d. L'écran de la console), alors que Write-Output écrit à la fois sur stdout AND et sur le flux de sortie [success] permettant la redirection . La redirection (et les flux en général) permet de diriger la sortie d'une commande en entrée vers une autre, y compris l'affectation à une variable.

> $message = Write-Output "Hello World"
> $message
"Hello World"

Ces fonctions similaires ne sont pas des alias, mais peuvent produire les mêmes résultats si l'on veut éviter de "polluer" le flux de réussite.

Write-Output est associé à Echo ou Write

Echo 'Hello world'
Write 'Hello world'

Ou, simplement en tapant "Hello world"!

'Hello world'

Tout cela entraînera la sortie de console attendue

Hello world

Un autre exemple d'alias dans PowerShell est le mappage commun des commandes d'invite de commandes plus anciennes et des commandes BASH aux applets de commande PowerShell. Tous les éléments suivants produisent une liste de répertoires du répertoire en cours.

C:\Windows> dir
C:\Windows> ls
C:\Windows> Get-ChildItem

Enfin, vous pouvez créer votre propre alias avec l'applet de commande Set-Alias! Par exemple, testons Test-NetConnection , qui est essentiellement l'équivalent PowerShell de la commande ping de l'invite de commandes, pour "ping".

Set-Alias -Name ping -Value Test-NetConnection

Maintenant, vous pouvez utiliser ping au lieu de Test-NetConnection ! Sachez que si l'alias est déjà utilisé, vous écraserez l'association.

L'alias sera vivant jusqu'à ce que la session soit active. Une fois que vous fermez la session et essayez d'exécuter l'alias que vous avez créé lors de votre dernière session, cela ne fonctionnera pas. Pour résoudre ce problème, vous pouvez importer tous vos alias depuis Excel dans votre session une fois, avant de commencer votre travail.

Le pipeline - Utilisation de la sortie d'une applet de commande PowerShell

L'une des premières questions que se posent les utilisateurs lorsqu'ils commencent à utiliser PowerShell pour créer des scripts est la manipulation de la sortie d'une applet de commande pour effectuer une autre action.

Le symbole du pipeline | est utilisé à la fin d'une applet de commande pour prendre les données exportées et les transmettre à la cmdlet suivante. Un exemple simple consiste à utiliser Select-Object pour afficher uniquement la propriété Name d'un fichier affiché dans Get-ChildItem:

Get-ChildItem | Select-Object Name
#This may be shortened to:
gci | Select Name

L'utilisation plus avancée du pipeline nous permet de canaliser la sortie d'une applet de commande dans une boucle foreach:

Get-ChildItem | ForEach-Object {
    Copy-Item -Path $_.FullName -destination C:\NewDirectory\ 
}

#This may be shortened to:
gci | % { Copy $_.FullName C:\NewDirectory\ }

Notez que l'exemple ci-dessus utilise la variable automatique $ _. $ _ est le court alias de $ PSItem qui est une variable automatique qui contient l'élément en cours dans le pipeline.

Commentant

Pour commenter les scripts d’alimentation en ajoutant la ligne au symbole # (dièse)

# This is a comment in powershell
Get-ChildItem

Vous pouvez également avoir des commentaires sur plusieurs lignes en utilisant <# et #> au début et à la fin du commentaire, respectivement.

<#
This is a 
multi-line
comment
#>
Get-ChildItem

Appeler des méthodes de bibliothèque .Net

Les méthodes de bibliothèque .Net statiques peuvent être appelées à partir de PowerShell en encapsulant le nom de classe complet dans le troisième cadre et en appelant ensuite la méthode en utilisant ::

#calling Path.GetFileName()
C:\> [System.IO.Path]::GetFileName('C:\Windows\explorer.exe')
explorer.exe

Les méthodes statiques peuvent être appelées à partir de la classe elle-même, mais l'appel de méthodes non statiques nécessite une instance de la classe .Net (un objet).

Par exemple, la méthode AddHours ne peut pas être appelée à partir de la classe System.DateTime elle-même. Il nécessite une instance de la classe:

C:\> [System.DateTime]::AddHours(15)
Method invocation failed because [System.DateTime] does not contain a method named 'AddHours'.
At line:1 char:1
+ [System.DateTime]::AddHours(15)
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    + CategoryInfo          : InvalidOperation: (:) [], RuntimeException
    + FullyQualifiedErrorId : MethodNotFound

Dans ce cas, nous créons d' abord un objet , par exemple:

C:\> $Object = [System.DateTime]::Now

Ensuite, nous pouvons utiliser des méthodes de cet objet, même les méthodes qui ne peuvent pas être appelées directement depuis la classe System.DateTime, comme la méthode AddHours:

C:\> $Object.AddHours(15)

Monday 12 September 2016 01:51:19

Créer des objets

La cmdlet New-Object est utilisée pour créer un objet.

# Create a DateTime object and stores the object in variable "$var"
$var = New-Object System.DateTime

# calling constructor with parameters
$sr = New-Object System.IO.StreamReader -ArgumentList "file path"

Dans de nombreux cas, un nouvel objet sera créé afin d'exporter des données ou de le transmettre à une autre commande. Cela peut être fait comme ça:

$newObject = New-Object -TypeName PSObject -Property @{
    ComputerName = "SERVER1"
    Role = "Interface"
    Environment = "Production"
}

Il y a plusieurs façons de créer un objet. La méthode suivante est probablement le moyen le plus court et le plus rapide de créer un objet PSCustomObject :

$newObject = [PSCustomObject]@{
    ComputerName = 'SERVER1'
    Role         = 'Interface'
    Environment  = 'Production'
}

Si vous avez déjà un objet, mais que vous n’avez besoin que d’une ou deux propriétés supplémentaires, vous pouvez simplement ajouter cette propriété à l’aide de Select-Object :

Get-ChildItem | Select-Object FullName, Name, 
    @{Name='DateTime'; Expression={Get-Date}}, 
    @{Name='PropertieName'; Expression={'CustomValue'}}

Tous les objets peuvent être stockés dans des variables ou passés dans le pipeline. Vous pouvez également ajouter ces objets à une collection, puis afficher les résultats à la fin.

Les collections d'objets fonctionnent bien avec Export-CSV (et Import-CSV). Chaque ligne du fichier CSV est un objet, chaque colonne une propriété.

Les commandes de format convertissent les objets en flux de texte pour l'affichage. Évitez d'utiliser les commandes Format- * jusqu'à la dernière étape d'un traitement de données, afin de préserver la convivialité des objets.