Skip to content
Learni
Voir tous les tutoriels
Scripting et Automatisation

Comment créer des scripts PowerShell avancés en 2026

18 minEXPERT
PowerShellAutomatisationScripting
Read in English

Introduction

PowerShell est devenu l'outil incontournable pour l'automatisation des tâches d'administration système et DevOps. En 2026, les exigences portent sur des scripts robustes, maintenables et réutilisables. Ce tutoriel vous guide pas à pas dans la création de scripts avancés exploitant les fonctionnalités modernes de PowerShell 7 : fonctions avec CmdletBinding, classes POO, gestion centralisée des erreurs et création de modules professionnels. Chaque exemple est immédiatement exécutable et adapté à des environnements de production.

Prérequis

  • PowerShell 7.4 ou supérieur installé
  • Connaissances intermédiaires en PowerShell (fonctions, pipelines)
  • Éditeur VS Code avec extension PowerShell
  • Droits d'exécution de scripts (Set-ExecutionPolicy)

Fonction avancée avec CmdletBinding

Get-SystemInfo.ps1
function Get-SystemInfo {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory)]
        [string[]]$ComputerName,
        [switch]$IncludeProcesses
    )
    begin {
        Write-Verbose "Début de la collecte d'informations"
    }
    process {
        foreach ($computer in $ComputerName) {
            $os = Get-CimInstance -ClassName Win32_OperatingSystem -ComputerName $computer
            $result = [PSCustomObject]@{
                ComputerName = $computer
                OSVersion    = $os.Version
                Uptime       = (Get-Date) - $os.LastBootUpTime
            }
            if ($IncludeProcesses) {
                $result | Add-Member -MemberType NoteProperty -Name Processes -Value (Get-Process -ComputerName $computer)
            }
            Write-Output $result
        }
    }
}

Cette fonction utilise CmdletBinding pour supporter -Verbose et -Debug. Les paramètres sont fortement typés et le pipeline est géré via process. L'objet retourné est structuré pour une utilisation ultérieure.

Validation avancée des paramètres

Get-SystemInfo.ps1
function Get-SystemInfo {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory)]
        [ValidatePattern('^[A-Za-z0-9-]+$')]
        [string[]]$ComputerName,
        [ValidateRange(1, 100)]
        [int]$Timeout = 30
    )
    # Corps de la fonction inchangé
}

ValidatePattern et ValidateRange évitent les entrées invalides avant exécution. Ces attributs fournissent des messages d'erreur clairs et automatiques.

Gestion centralisée des erreurs

Invoke-SafeCommand.ps1
function Invoke-SafeCommand {
    [CmdletBinding()]
    param([scriptblock]$ScriptBlock)
    try {
        & $ScriptBlock
    }
    catch [System.Management.Automation.RuntimeException] {
        Write-Error "Erreur d'exécution : $($_.Exception.Message)" -ErrorAction Stop
    }
    catch {
        Write-Error "Erreur inattendue : $($_.Exception.Message)" -ErrorAction Stop
    }
    finally {
        Write-Verbose "Exécution terminée"
    }
}

La structure try/catch/finally avec typage spécifique des exceptions garantit une gestion précise et la possibilité d'arrêter le script via ErrorAction Stop.

Définition d'une classe PowerShell

SystemReport.ps1
class SystemReport {
    [string]$ComputerName
    [datetime]$Timestamp
    hidden [int]$InternalId
    SystemReport([string]$name) {
        $this.ComputerName = $name
        $this.Timestamp = Get-Date
        $this.InternalId = Get-Random
    }
    [string] ToString() {
        return "Rapport pour $($this.ComputerName) généré le $($this.Timestamp)"
    }
}

Les classes permettent une approche orientée objet avec encapsulation. Le mot-clé hidden protège les propriétés internes tout en conservant la lisibilité du code.

Création d'un module PowerShell complet

MyAdminTools.psm1
function Get-SystemInfo { <# code de la fonction ici #> }
function Invoke-SafeCommand { <# code ici #> }
Export-ModuleMember -Function Get-SystemInfo, Invoke-SafeCommand
# Fichier .psd1 associé :
# @{ ModuleVersion = '1.0.0'; RootModule = 'MyAdminTools.psm1'; FunctionsToExport = '*' }

Un module bien structuré expose uniquement les fonctions publiques via Export-ModuleMember. Le fichier manifeste .psd1 versionne et documente le module pour une distribution professionnelle.

Bonnes pratiques

  • Toujours utiliser [CmdletBinding()] et des paramètres typés
  • Implémenter une gestion d'erreurs explicite avec try/catch
  • Documenter chaque fonction avec des commentaires help
  • Versionner les modules et utiliser un manifeste .psd1
  • Tester systématiquement avec Pester avant déploiement

Erreurs courantes à éviter

  • Omettre le support du pipeline dans les fonctions avancées
  • Utiliser Write-Host au lieu de Write-Output ou Write-Verbose
  • Ne pas valider les entrées utilisateur avec des attributs Validate*
  • Ignorer la gestion des sessions distantes avec Enter-PSSession ou Invoke-Command

Pour aller plus loin

Approfondissez vos compétences avec nos formations certifiantes sur l'automatisation PowerShell et DevOps. Découvrez nos formations Learni.