1 — Fondamentaux PowerShell Avancés

L’automatisation Windows repose entièrement sur la maîtrise avancée de PowerShell. Ce module couvre les concepts clés pour écrire des scripts efficaces et sécurisés.

Variables, Types et Conversion

Les variables sont créées avec le symbole dollar ($). PowerShell est fortement typé, ce qui signifie qu’il peut forcer le type d’une variable pour garantir la cohérence des données.

# Création d'une variable standard
$chemin = "C:Logs"

# Variable typée [string]
[string]$nomUtilisateur = "DupontJ"

# Conversion de type (String vers Integer)
$stringAge = "30"
[int]$intAge = $stringAge + 5
# $intAge vaut 35

Gestion des Profils et Modules

Le Profil PowerShell (fichier Microsoft.PowerShell_profile.ps1) permet d’exécuter automatiquement des commandes au démarrage de la console. Les Modules sont des ensembles de Cmdlets que vous devez parfois charger.

# Afficher le chemin de votre profil
$PROFILE

# Installer un module depuis le PowerShell Gallery
Install-Module -Name PSWindowsUpdate

# Afficher les commandes d'un module
Get-Command -Module ActiveDirectory

2 — Le Système d’Objets et le Pipeline

La principale force de PowerShell est son utilisation du pipeline pour transférer des objets dotés de propriétés et de méthodes, et non du texte brut.

Explorer les Objets (Get-Member)

La Cmdlet Get-Member est indispensable. Elle vous permet de connaître les propriétés (données) et les méthodes (actions) de tout objet qui passe dans le pipeline.

# Afficher les propriétés et méthodes de l'objet service
Get-Service -Name Spooler | Get-Member

Filtrage Avancé (Where-Object)

Le filtrage se fait généralement avec Where-Object ou son alias ?. Le critère est encapsulé entre accolades {}.

3 — Structures de Contrôle et Fonctions

Pour écrire des scripts qui prennent des décisions et effectuent des actions répétitives, vous devez maîtriser les structures de contrôle.

Conditionnelles (If/Elseif/Else)

La structure If exécute un bloc de code si une condition est vraie.

$EspaceLibre = (Get-Volume C).SizeRemaining / 1GB

if ($EspaceLibre -lt 10) {
    Write-Warning "Alerte : Espace disque insuffisant sur le lecteur C!"
}
elseif ($EspaceLibre -lt 50) {
    Write-Host "Attention : Espace disque faible."
}
else {
    Write-Host "Espace disque OK."
}

Boucles (ForEach et While)

Les boucles permettent d’itérer sur une collection d’objets ou d’exécuter un bloc de code tant qu’une condition est vraie.

# Boucle ForEach : Traiter chaque utilisateur
$utilisateurs = Get-ADUser -Filter * -SearchBase "OU=AnciensEmployes,DC=corp"
foreach ($user in $utilisateurs) {
    Disable-ADAccount -Identity $user.SamAccountName
    Write-Host "Compte $($user.SamAccountName) désactivé."
}

Création de Fonctions (Cmdlets Personnalisées)

Les fonctions vous permettent de regrouper du code réutilisable. Pour qu’une fonction se comporte comme une Cmdlet, utilisez [CmdletBinding()] et des blocs Param() et process {}.

function Get-DiskSpaceWarning {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory=$true)]
        [string]$DriveLetter
    )
    # Le code de la fonction...
    Write-Host "Vérification du lecteur $DriveLetter..."
}

4 — Gestion des Données (CSV, JSON, XML)

L’automatisation implique souvent d’importer des listes d’utilisateurs/serveurs ou d’exporter des rapports. PowerShell gère nativement les formats de données standard.

Import et Export CSV

Le format CSV est le plus couramment utilisé pour l’échange de listes d’objets.

# Exporter la liste des services vers un fichier CSV
Get-Service | Select Name, Status, StartType | Export-Csv -Path "C:RapportsServices.csv" -NoTypeInformation

# Importer une liste d'utilisateurs à créer
$ListeUtilisateurs = Import-Csv -Path "C:DataListe.csv"
foreach ($user in $ListeUtilisateurs) {
    New-ADUser -Name $user.NomComplet -SamAccountName $user.Username
}

Utilisation de JSON et XML

JSON et XML sont utilisés pour les configurations, les API Web et l’échange de données structurées.

# Convertir un objet PowerShell en format JSON
$data = Get-Service -Name *winrm* | Select Name, Status
$data | ConvertTo-Json -Depth 3 | Out-File C:Configservice.json

# Lire un fichier JSON et en faire un objet PowerShell utilisable
$config = Get-Content C:Configconfig.json | ConvertFrom-Json

5 — Scripting Avancé et Gestion des Erreurs

Des scripts robustes nécessitent une gestion proactive des erreurs et un mécanisme de journalisation.

Gestion des Erreurs (Try/Catch/Finally)

Par défaut, PowerShell génère des erreurs non-fatales (terminating errors). Pour que Catch fonctionne, vous devez forcer les Cmdlets à générer des erreurs fatales (non-terminating errors) en utilisant -ErrorAction Stop.

Try {
    # Cette commande échoue et arrête le bloc Try
    Get-Service -Name "ServiceInexistant" -ErrorAction Stop
    Write-Host "Cette ligne ne sera pas exécutée."
}
Catch {
    Write-Error "L'erreur suivante s'est produite : $($_.Exception.Message)"
}
Finally {
    # Ce bloc s'exécute toujours, qu'il y ait erreur ou non
    Write-Host "Le processus de vérification est terminé."
}

Journalisation (Logging)

Pour le débogage et le suivi en production, vous devez enregistrer les événements dans le journal d’événements Windows.

# Écrire un événement dans le journal d'application de Windows
Write-EventLog -LogName Application -Source "MonScript" -EntryType Information -EventId 100 -Message "Démarrage du script réussi."

6 — Administration à Distance et PSSession

L’administration de multiples serveurs sans interface graphique passe par la Communication à Distance (Remoting) de PowerShell via le protocole WinRM.

Connexion à Distance (Enter-PSSession)

Enter-PSSession ouvre une console interactive sur le serveur distant.

# Se connecter à un serveur (nécessite que WinRM soit activé)
Enter-PSSession -ComputerName SRV-WEB-01

# [SRV-WEB-01]: PS C:> # Vous êtes maintenant sur le serveur distant

Exécution de Commandes Multiples (Invoke-Command)

Invoke-Command vous permet d’exécuter un script ou un bloc de code sur un ou plusieurs ordinateurs simultanément, sans ouvrir de session interactive.

7 — Tâches Planifiées et Automatisation

L’objectif final du scripting est de mettre en place des processus qui s’exécutent de manière fiable et autonome.

Planificateur de Tâches Windows

Le Planificateur de tâches permet de déclencher l’exécution de scripts PowerShell à des moments précis. Il est essentiel d’utiliser powershell.exe comme programme et de passer le script en argument.

Exemple d’arguments de tâche planifiée :

# Programme : C:WindowsSystem32WindowsPowerShellv1.0powershell.exe
# Arguments : -ExecutionPolicy Bypass -File "C:ScriptsSauvegarde.ps1"

Cmdlets pour les Tâches Planifiées

Vous pouvez créer et gérer les tâches planifiées entièrement via PowerShell.

# Créer une action (l'exécution du script)
$action = New-ScheduledTaskAction -Execute 'powershell.exe' -Argument '-File "C:Scriptsrapport.ps1"'

# Créer un déclencheur (tous les jours à 4h00)
$trigger = New-ScheduledTaskTrigger -Daily -At 4am

# Enregistrer la tâche
Register-ScheduledTask -Action $action -Trigger $trigger -TaskName "Rapport Quotidien" -User "System"