Checklist des opérations PowerShell en production avec exemples pratiques

Introduction

PowerShell est excellent pour l'automatisation Windows et multiplateforme, mais la production exige cohérence, sécurité et observabilité. Cette PowerShell checklist vous propose un guide pratique avec du code prêt à copier, adapter et déployer. Elle couvre :

• Configuration et durcissement
• Sécurisation des identifiants et secrets
• Journalisation et supervision
• Gestion des erreurs et idempotence
• Déploiement et versioning
• Maintenance et sauvegardes
• Mises à niveau et compatibilité
• Pièges de production à éviter

Servez-vous-en comme baseline d'équipe pour réduire les surprises et rendre vos PowerShell operations prévisibles et « ennuyeuses » dans le bon sens.

Vue d'ensemble du workflow

Un flux de travail prévisible réduit le rework et rend les résultats répétables. Mettez en place ces étapes :

1. Baseline et durcissement

• Activer StrictMode et une politique d'erreur sûre
• Vérifier ExecutionPolicy et le besoin réel de remoting

1. Sécuriser les secrets

• Stocker les identifiants de façon sûre, jamais en code

1. Patron de script sûr

• Utiliser CmdletBinding, ShouldProcess, -WhatIf, -Confirm
• Valider les paramètres et retourner des sorties structurées

1. Observabilité

• Start-Transcript pour les sessions adhoc
• Logs structurés (JSONL)
• Écritures dans l'Event Log pour les actions/échecs clés

1. Packager et versionner

• Créer des modules avec manifeste, pinner les dépendances
• Signer les scripts lorsque possible

1. Livrer en sécurité

• Petits incréments avec rollback clair

1. Exploiter et maintenir

• Tâches planifiées pour les jobs récurrents
• Health checks et rotation de logs

1. Sauvegardes

• Scripts, configs et caches de modules sauvegardés et restaurables

1. Mises à niveau

• Valider les versions et la compatibilité d'abord sur un petit anneau

1. Revoir et améliorer

• Capitaliser les apprentissages et affiner les défauts

Configuration de base

Durcissez le comportement par défaut du shell et la configuration de l'hôte.

# À exécuter en session élevée si nécessaire
# 1) Politique d'exécution (ajustez selon la politique de l'organisation)
Set-ExecutionPolicy -Scope LocalMachine -ExecutionPolicy RemoteSigned -Force

# 2) Mode strict et arrêt sur erreurs
Set-StrictMode -Version Latest
$ErrorActionPreference = 'Stop'

# 3) Activer le remoting uniquement si vous en avez besoin
#    Configurer pare-feu et authentification selon votre politique de sécurité
Enable-PSRemoting -Force

# 4) S'assurer que les dossiers de scripts sont verrouillés
$opsRoot = 'C:\Ops'
New-Item -ItemType Directory -Path $opsRoot -Force | Out-Null
# Exemple : restreindre aux Administrators et à un compte de service
icacls $opsRoot /inheritance: r | Out-Null
icacls $opsRoot /grant 'Administrators:(OI)(CI)F' | Out-Null

Principe du moindre privilège : privilégiez des contextes utilisateur standard ou des endpoints contraints plutôt qu'un admin complet.

Exemple optionnel de rôle JEA (Just Enough Administration) :

# Créer un rôle minimal autorisant l'inspection et le redémarrage de services
$rcPath = 'C:\Program Files\WindowsPowerShell\Modules\Company.Jea\RoleCapabilities\OpsMaintenance.psrc'
New-Item -ItemType Directory (Split-Path $rcPath) -Force | Out-Null
New-PSRoleCapabilityFile -Path $rcPath -VisibleCmdlets 'Get-Service','Restart-Service'

Secrets et identifiants

Règles de base :

• Ne jamais coder en dur des secrets dans le code ou le dépôt
• Préférer un coffre de secrets ; à défaut, des exports protégés DPAPI pour un usage local
• Verrouiller les ACL des fichiers et contrôler l'accès aux logs

Exemple : stocker un credential pour un usage sur la même machine et le même contexte utilisateur.

# Configuration unique par un compte opérateur
$credPath = 'C:\Ops\svc_cred.xml'
Get-Credential | Export-Clixml -Path $credPath
icacls $credPath /inheritance: r | Out-Null
icacls $credPath /grant "$($env: USERNAME):(R)" | Out-Null

# Dans votre script
$svcCred = Import-Clixml -Path $credPath

Ne jamais committer des secrets exportés au contrôle de version. Faites tourner et révoquez régulièrement les accès.

Journalisation et supervision

Objectif : inspection locale rapide et visibilité centrale.

1. Transcripts pour les sessions ad hoc :

Start-Transcript -Path 'C:\Logs\ops-transcript.txt' -Append
# ... exécuter des commandes ...
Stop-Transcript

1. Helper de logging JSONL structuré :

$LogPath = 'C:\Logs\ops.jsonl'
New-Item -ItemType Directory -Path (Split-Path $LogPath) -Force | Out-Null

function Write-LogJson {
  param(
    [Parameter(Mandatory)] [ValidateSet('INFO','WARN','ERROR')] [string]$Level,
    [Parameter(Mandatory)] [string]$Message,
    [hashtable]$Data
  )
  $obj = [ordered]@{
    ts    = (Get-Date).ToString('o')
    level = $Level
    msg   = $Message
    data  = $Data
  }
  $line = $obj | ConvertTo-Json -Compress
  Add-Content -Path $LogPath -Value $line -Encoding utf8
}

Write-LogJson -Level INFO -Message 'Startup' -Data @{ host = $env: COMPUTERNAME }

1. Source et écritures Windows Event Log :

$src = 'Company.PowerShell.Ops'
if (-not [System.Diagnostics.EventLog]::SourceExists($src)) {
  New-EventLog -LogName Application -Source $src
}
Write-EventLog -LogName Application -Source $src -EntryType Information -EventId 1001 -Message 'Ops script started.'

Gestion des erreurs et idempotence

Traitez les erreurs en citoyens de première classe et rendez les scripts sûrs à relancer.

• Définir $ErrorActionPreference = 'Stop' en contexte d'automatisation
• Utiliser try { } catch { } finally { }
• Supporter -WhatIf et -Confirm via SupportsShouldProcess pour toute action de changement
• Vérifier l'état courant et n'appliquer que les diffs (idempotence)

Exemple : garantir qu'un service est démarré, de manière sûre et idempotente.

function Ensure-ServiceRunning {
  [CmdletBinding(SupportsShouldProcess = $true)]
  param(
    [Parameter(Mandatory)] [string]$Name
  )
  try {
    $svc = Get-Service -Name $Name -ErrorAction Stop
    if ($svc.Status -ne 'Running') {
      if ($PSCmdlet.ShouldProcess("service $Name", 'Start')) {
        Start-Service -Name $Name -ErrorAction Stop
        Write-LogJson -Level INFO -Message 'Service started' -Data @{ name = $Name }
      }
    } else {
      Write-LogJson -Level INFO -Message 'Service already running' -Data @{ name = $Name }
    }
  } catch {
    Write-LogJson -Level ERROR -Message 'Failed to ensure service' -Data @{ name = $Name; err = $_.Exception.Message }
    throw
  }
}

# Dry run
Ensure-ServiceRunning -Name 'Spooler' -WhatIf

Déploiement et versioning

Packager le code réutilisable et livrer avec contrôle.

1. Manifeste de module et pinning des dépendances :

$moduleRoot = 'C:\Ops\Company.Ops'
New-Item -ItemType Directory -Path $moduleRoot -Force | Out-Null

New-ModuleManifest -Path (Join-Path $moduleRoot 'Company.Ops.psd1') `
  -RootModule 'Company.Ops.psm1' `
  -ModuleVersion '1.0.0' `
  -Author 'Ops Team' `
  -Description 'Operations helpers for production' `
  -RequiredModules @(@{ ModuleName = 'Microsoft.PowerShell.Management'; ModuleVersion = '7.0.0.0' })

1. Signature de scripts (avec un certificat de signature adapté) :

$cert = Get-ChildItem Cert:\CurrentUser\My -CodeSigningCert | Select-Object -First 1
Set-AuthenticodeSignature -FilePath 'C:\Ops\Ensure-Service.ps1' -Certificate $cert

1. Releases versionnées :

• Incrémenter la version du module à chaque release
• Tenir un CHANGELOG et tagger les builds
• Distribuer via le canal approuvé (partage, dépôt de packages, gestion de config)

Maintenance et sauvegardes

Automatisez le récurrent et rendez les restaurations « ennuyeuses ».

1. Exemple de tâche planifiée pour une rotation nocturne de logs :

$taskName = 'RotateLogs'
$action = New-ScheduledTaskAction -Execute 'pwsh.exe' -Argument '-NoProfile -File C:\Ops\Rotate-Logs.ps1'
$trigger = New-ScheduledTaskTrigger -Daily -At 2:00AM
Register-ScheduledTask -TaskName $taskName -Action $action -Trigger $trigger -RunLevel Highest -User 'SYSTEM'

1. Sauvegarder scripts, configs et versions de modules :

# Sauvegarder les versions de module vers un partage
Save-Module -Name Company.Ops -RequiredVersion 1.0.0 -Path \\backup\psmodules

# Sauvegarder la configuration
$cfg = @{ Services = @('Spooler','W32Time'); LogPath = 'C:\Logs\ops.jsonl' }
$cfg | Export-Clixml 'C:\Ops\config.xml'

1. Tester régulièrement les restaurations :

# Restaurer le module vers un chemin temporaire puis l'importer
Save-Module -Name Company.Ops -RequiredVersion 1.0.0 -Path 'C:\Temp\Cache'
Import-Module 'C:\Temp\Cache\Company.Ops\1.0.0\Company.Ops.psd1' -Force

Mises à jour et compatibilité

Réduisez les surprises lors des changements de runtime ou de dépendances.

• Vérifier explicitement les versions :

$PSVersionTable.PSVersion
Get-Module | Select-Object Name, Version, Path

• Exécuter les scripts avec -NoProfile pour un comportement déterministe
• Valider d'abord sur un petit anneau, puis étendre
• Garder Windows PowerShell 5.1 et PowerShell 7 côte à côte si besoin
• Préférer les versions LTS lorsque disponibles

Pièges fréquents en production

Évitez ces erreurs, appliquez le correctif :

• Tout exécuter en admin
• Correctif : moindre privilège ou rôles JEA

• Secrets dans le code ou les logs
• Correctif : coffres/exports protégés, rédaction à l'écriture

• Ignorer les erreurs
• Correctif : $ErrorActionPreference = 'Stop' et blocs try/catch

• Pas de dry-run
• Correctif : SupportsShouldProcess, respecter -WhatIf et -Confirm

• Pas de logs ou seulement du console output
• Correctif : JSONL centralisé et entrées Event Log

• Scripts non idempotents
• Correctif : vérifier l'état et n'appliquer que les changements

• Pas de timeouts ou retries aux appels distants
• Correctif : définir -TimeoutSec, ajouter des retries avec backoff si pertinent

• Mélanger interactif et automatisation
• Correctif : paramétrer, échouer vite si entrée manquante, éviter les invites en unattended

Plan pilote local

Démarrez par un pilote inspectable pour apprendre vite et réduire le risque. Exemple : garantir que le service Print Spooler est Running sur un hôte.

Périmètre et succès :

• Objectif : s'assurer que le service Spooler est Running
• Indicateur de succès : code de sortie 0, entrée JSONL avec level=INFO, EventId 1001 écrit
• Temps d'exécution : moins de 2 secondes sur la cible

Étapes :

1. Créer un dossier de travail et les logs

New-Item -ItemType Directory -Path C:\Ops -Force | Out-Null
New-Item -ItemType Directory -Path C:\Logs -Force | Out-Null

1. Ajouter le helper de logs et la fonction Ensure-ServiceRunning (sections précédentes) dans C:\Ops\Ensure-Service.ps1.

1. Dry-run local

pwsh -NoProfile -File C:\Ops\Ensure-Service.ps1 -WhatIf
Get-Content C:\Logs\ops.jsonl -Tail 5

1. Exécution réelle

pwsh -NoProfile -File C:\Ops\Ensure-Service.ps1
wevtutil qe Application /c:5 /q:"*[System[Provider[@Name='Company.PowerShell.Ops']]]" /f: text

1. Planifier toutes les heures avec plan de rollback (désactiver la tâche)

$taskName = 'EnsureSpooler'
$action = New-ScheduledTaskAction -Execute 'pwsh.exe' -Argument '-NoProfile -File C:\Ops\Ensure-Service.ps1'
$trigger = New-ScheduledTaskTrigger -Once -At (Get-Date).AddMinutes(5) -RepetitionInterval (New-TimeSpan -Minutes 60) -RepetitionDuration ([TimeSpan]::MaxValue)
Register-ScheduledTask -TaskName $taskName -Action $action -Trigger $trigger -RunLevel Highest -User 'SYSTEM'
# Rollback: Unregister-ScheduledTask -TaskName EnsureSpooler -Confirm:$false

1. Documenter les enseignements et étendre au prochain service ou à un anneau d'hôtes plus large.

Conclusion

Vous disposez maintenant d'une PowerShell checklist prête pour la production et d'exemples pratiques immédiatement applicables :

• Durcir l'environnement et appliquer des défauts stricts avec arrêt sur erreur
• Protéger les secrets, journaliser en format structuré, écrire dans l'Event Log
• Concevoir des scripts idempotents avec -WhatIf et une gestion d'erreurs sûre
• Packager, versionner et signer ce que vous livrez
• Automatiser la maintenance, sauvegarder code et configs, tester les restaurations
• Mettre à niveau par anneaux avec vérifications explicites de compatibilité

Démarrez avec le pilote local, mesurez le succès, itérez. En gardant sécurité, observabilité et idempotence comme valeurs par défaut, vos PowerShell operations deviennent prévisibles et à faible risque. Cela s'aligne sur les PowerShell best practices et renforce votre PowerShell production et votre PowerShell maintenance au quotidien.