Checklist PowerShell pour les opérations 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é. Ce guide vous fournit une checklist de production pratique avec du code que vous pouvez copier, adapter et déployer. Il se concentre sur :

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

Utilisez-le comme référence d'équipe pour réduire les surprises et rendre les opérations ennuyeuses, dans le bon sens du terme.

Vue d'ensemble du workflow

Un workflow prévisible réduit le retravail et rend les résultats reproductibles. Implémentez ces étapes :

1. Établir la base et durcir

• Activer le mode strict et une politique d'erreur sûre
• Vérifier la politique d'exécution et les besoins de communication à distance

1. Sécuriser les secrets

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

1. Modèle de script sûr

• Utiliser CmdletBinding, ShouldProcess, -WhatIf, -Confirm
• Valider les paramètres et retourner une sortie structurée

1. Observabilité

• Start-Transcript pour les sessions
• Journaux structurés (JSONL)
• Entrées dans le journal d'événements pour les actions clés et les échecs

1. Empaqueter et versionner

• Créer des modules avec manifestes, verrouiller les dépendances
• Signer les scripts si possible

1. Déployer en toute sécurité

• Petits changements incrémentaux avec retour arrière clair

1. Exploiter et maintenir

• Tâches planifiées pour les travaux récurrents
• Vérifications de santé et rotation des journaux

1. Sauvegardes

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

1. Mises à niveau

• Valider les versions et la compatibilité sur un petit périmètre d'abord

1. Revoir et améliorer

• Capturer les enseignements et affiner les valeurs par défaut

Configuration de base

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

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

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

# 3) Activer la communication à distance seulement si nécessaire
# Configurer le pare-feu et l'authentification selon votre politique de sécurité
Enable-PSRemoting -Force

# 4) Verrouiller les répertoires de scripts
$opsRoot = 'C:\Ops'
New-Item -ItemType Directory -Path $opsRoot -Force | Out-Null
# Exemple : restreindre aux Administrateurs 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 les contextes utilisateur standards ou les points de terminaison contraints plutôt que l'administration complète.

Exemple optionnel de capacité de rôle JEA (Just Enough Administration) : administration juste nécessaire :

# Créer un rôle minimal autorisant l'inspection et le redémarrage de service
$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'

Sécurisation des identifiants et secrets

Règles de base :

• Ne jamais coder en dur les secrets dans le code ou le dépôt
• Privilégier un coffre à secrets ; sinon utiliser des exports protégés par DPAPI (Data Protection Application Programming Interface) : API de protection des données Windows pour un usage local
• Verrouiller les ACL des fichiers et l'accès aux journaux

Exemple : stocker un identifiant pour une utilisation 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 commettez jamais les secrets exportés dans le contrôle de version. Effectuez une rotation et révoquez l'accès régulièrement.

Journalisation et surveillance

Visez une inspection locale rapide et une visibilité centralisée.

1. Transcripts pour sessions ad hoc

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

1. Assistant de journalisation JSONL structurée

$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 'Démarrage' -Data @{ host = $env:COMPUTERNAME }

1. Source et écriture dans le journal d'événements Windows

$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 'Script d\'opérations démarré.'

Gestion des erreurs et idempotence

Traitez toujours les erreurs comme des citoyens de premier plan et rendez les scripts sûrs à réexécuter.

• Définir $ErrorActionPreference = 'Stop' dans les contextes d'automatisation
• Utiliser try { } catch { } finally { }
• Prendre en charge -WhatIf et -Confirm avec SupportsShouldProcess pour les actions de modification
• Vérifier l'état courant et n'appliquer que les différences (idempotence)

Exemple : s'assurer qu'un service est en cours d'exécution, de façon 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", 'Démarrer')) {
                Start-Service -Name $Name -ErrorAction Stop
                Write-LogJson -Level INFO -Message 'Service démarré' -Data @{ name = $Name }
            }
        } else {
            Write-LogJson -Level INFO -Message 'Service déjà en cours d\'exécution' -Data @{ name = $Name }
        }
    } catch {
        Write-LogJson -Level ERROR -Message 'Échec de la vérification du service' -Data @{ name = $Name; err = $_.Exception.Message }
        throw
    }
}

# Exécution à blanc
Ensure-ServiceRunning -Name 'Spooler' -WhatIf

Déploiement et versioning

Empaquetez le code réutilisable et livrez-le avec contrôle.

1. Manifeste de module et verrouillage 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 'Assistants d\'opérations pour la production' \
 -RequiredModules @(@{ ModuleName = 'Microsoft.PowerShell.Management'; ModuleVersion = '7.0.0.0' })

1. Signature de script (utiliser un certificat de signature de code approprié)

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

1. Versions publiées

• Incrémenter la version du module à chaque publication
• Tenir un CHANGELOG et taguer les builds
• Distribuer via votre canal approuvé (partage de fichiers, dépôt de paquets ou gestion de configuration)

Maintenance et sauvegardes

Automatisez les tâches courantes et rendez les restaurations banales.

1. Exemple de tâche planifiée pour la rotation nocturne des journaux

$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 les scripts, configurations et versions des modules

# Sauvegarder les versions des modules sur 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 chemins de restauration

# Restaurer le module vers un chemin temporaire et 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 à niveau et compatibilité

Minimisez les surprises lors du passage à de nouveaux runtimes ou 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 dans un petit périmètre d'abord, puis étendre
• Maintenir Windows PowerShell 5.1 et PowerShell 7 côte à côte si nécessaire
• Privilégier les versions LTS (Long Term Support) : support à long terme lorsque disponibles

Pièges courants en production

Évitez ces erreurs et appliquez la correction.

• Tout exécuter en tant qu'administrateur → Correction : utiliser le moindre privilège ou les rôles JEA
• Secrets dans le code ou les journaux → Correction : utiliser des magasins protégés, masquer à l'écriture
• Ignorer les erreurs → Correction : $ErrorActionPreference = 'Stop' et envelopper avec try/catch
• Absence de prise en charge du mode simulation → Correction : implémenter SupportsShouldProcess, respecter -WhatIf et -Confirm
• Pas de journaux ou seulement une sortie console ad hoc → Correction : JSONL centralisé et entrées dans le journal d'événements
• Scripts non idempotents → Correction : vérifier l'état courant et n'appliquer que les changements
• Pas de délais ni de nouvelles tentatives sur les appels distants → Correction : définir -TimeoutSec, ajouter une nouvelle tentative avec backoff si approprié
• Mélanger logique interactive et automatisation → Correction : paramétrer, échouer rapidement si entrées manquantes, éviter les invites dans les exécutions non supervisées

Plan pilote local

Commencez par un petit pilote inspectable pour apprendre vite et réduire le risque. Exemple de pilote : s'assurer que le service Spouleur d'impression est en cours d'exécution sur un hôte.

Périmètre et succès

• Objectif : garantir que le service Spooler est Running
• Métrique de succès : code de sortie 0, entrée JSONL avec level=INFO, EventId 1001 écrit
• Durée d'exécution : moins de 2 secondes sur l'hôte cible

Étapes

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

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

1. Ajouter l'assistant de journalisation et la fonction Ensure-ServiceRunning (des sections précédentes) dans C:\Ops\Ensure-Service.ps1.

1. Exécution à blanc localement

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 chaque heure avec plan de retour arrière (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'
# Retour arrière : Unregister-ScheduledTask -TaskName EnsureSpooler -Confirm:$false

1. Documenter les constatations et étendre au service ou au prochain anneau d'hôtes.

Conclusion

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

• Durcir l'environnement et imposer des défauts stricts, arrêt sur erreur
• Protéger les secrets, journaliser sous forme structurée et écrire dans le journal d'événements
• Concevoir des scripts idempotents avec -WhatIf et une gestion d'erreur sûre
• Empaqueter, versionner et signer ce que vous livrez
• Automatiser la maintenance, sauvegarder le code et les configurations, et tester les restaurations
• Mettre à niveau par petits anneaux avec vérifications de compatibilité explicites

Commencez par le pilote local, mesurez le succès et itérez. Maintenez la sécurité, l'observabilité et l'idempotence comme valeurs par défaut, et la production deviendra prévisible et à faible risque.