Windows Server Backup 2022 : configurer une rétention de 14 jours (wbadmin, PowerShell, planification)

Vos sauvegardes Windows Server Backup s’écrasent d’un jour sur l’autre ? Voici comment conserver un historique fiable de 14 jours avec WSB 2022 : comprendre les limites de rétention, choisir le bon scénario (disque dédié vs partage réseau) et automatiser sauvegarde + purge.

Sommaire

Vue d’ensemble de la question

Un administrateur exécute une sauvegarde quotidienne avec Windows Server Backup (WSB) et constate que la nouvelle version remplace la précédente. Il souhaite garder 14 jours d’historique. WSB ne propose pas un bouton « Conserver x jours ». Le comportement de rétention dépend du type de cible :

Disque dédié ajouté dans WSB : WSB empile des versions incrémentielles et supprime les plus anciennes uniquement en cas de manque d’espace (ou via une commande de purge).
Partage réseau (UNC) : par défaut, un seul jeu de sauvegarde par chemin ; sans stratégie, une exécution peut écraser la précédente. Il faut donc « faire tourner » le dossier cible et purger les anciens dossiers par script.
État du système : WSB sait limiter le nombre de versions via une commande spécifique de rétention.

Réponse & solutions

Constats	Solutions proposées
Pas de paramètre « Conserver x jours » dans l’interface WSB. Les versions cohabitent sur un disque dédié et les plus anciennes ne sont supprimées qu’en cas de manque d’espace.	Scripts PowerShell pour piloter la rotation : Script de sauvegarde (`wbadmin start backup …`) et script de nettoyage basé sur la date (`Get-ChildItem` → `Remove-Item`). Planification avec le Planificateur de tâches : un job quotidien pour la sauvegarde, un job décalé pour la purge. Surveillance de l’espace et des journaux WSB. Alternatives : Azure Backup (MARS), outils tiers (Veeam, Altaro, DPM…), déduplication du volume cible.
Pour un disque cible déclaré dans WSB (et non un partage réseau), on peut forcer une rétention par nombre de versions.	`wbadmin delete backup -keepVersions:14 -backupTarget:<lettre> -quiet` (éventuellement `-machine:<NomServeur>` si le disque contient des sauvegardes de plusieurs machines).
La commande `wbadmin delete systemstatebackup -keepVersions:14` ne vise que les sauvegardes d’état du système.	À utiliser en complément si vous effectuez des system state backups réguliers (AD, Registre, etc.).
WSB ne compresse ni ne chiffre par défaut ; la cible peut se remplir plus vite que prévu.	Utiliser BitLocker sur le disque de sauvegarde, SMB Encryption côté partage si pertinent, et/ou activer la déduplication sur le volume cible compatible.

Comment fonctionne réellement la rétention dans WSB 2022

Disque dédié (USB/SAS/iSCSI) ajouté via WSB : WSB crée un store de versions (bloc incrémentiel) et gère l’espace. Il n’y a pas de curseur « 14 jours ». Vous pouvez toutefois purger en conservant les n dernières versions (pas « jours »).
Partage réseau : WSB n’empile pas de versions incrémentielles comme sur disque dédié. Par défaut un seul jeu par chemin est conservé. Pour garder 14 jours, on change le chemin cible chaque jour (un sous-dossier daté) puis on supprime les dossiers > 14 jours.
System State : rétention native par nombre de versions via wbadmin delete systemstatebackup -keepVersions.

Important : keepVersions:14 conserve les 14 dernières versions. Si vous lancez plusieurs sauvegardes par jour, cela ne couvrira pas 14 jours calendaires. Pour « 14 jours », préférez une purge par date.

Choisir la bonne stratégie selon la cible

Scénario	Comportement par défaut	Objectif « 14 jours »	Commande/Script de purge	Points d’attention
Disque dédié déclaré dans WSB	Versions incrémentielles empilées, suppression auto en cas de manque d’espace.	Conserver un nombre de versions suffisant pour couvrir 14 jours (idéalement 14 versions si une sauvegarde/jour).	`wbadmin delete backup -backupTarget:F: -keepVersions:14 -quiet`	Surveillez l’espace ; si insuffisant, WSB peut purger plus tôt que prévu.
Partage réseau (UNC)	Un seul jeu par chemin ; risque d’écrasement.	Utiliser un sous-dossier daté par jour comme cible ; purger les dossiers > 14 jours.	PowerShell : supprimer les répertoires datés > 14 jours (voir scripts ci‑dessous).	Créer les dossiers avant l’exécution WSB ; éviter tout recouvrement temporel avec la purge.
System State	Versions séparées.	Limiter à 14 versions.	`wbadmin delete systemstatebackup -keepVersions:14 -quiet`	Bien distinguer la rétention « System State » du reste (volumes/fichiers).

Scripts PowerShell prêts à l’emploi

1) Sauvegarde vers un disque dédié (et purge par versions)

Script type Backup-WSB-Disque.ps1 : une exécution par jour, puis conservation des 14 dernières versions.

# Backup-WSB-Disque.ps1
# Exécuter en tant qu'Administrateur
param(
  [string]$Target = 'F:',                # Lettre du disque ajouté dans WSB
  [string]$Include = 'C:,D:',            # Volumes à inclure
  [int]$KeepVersions = 14,               # 14 dernières versions
  [switch]$AllCritical = $true,
  [switch]$VssFull = $true
)

function Assert-Admin {
$id = [Security.Principal.WindowsIdentity]::GetCurrent()
$p = New-Object Security.Principal.WindowsPrincipal($id)
if (-not $p.IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)) {
throw "Exécutez ce script en tant qu'Administrateur."
}
}

Assert-Admin

$logRoot = Join-Path $Target 'WSB-Logs'
New-Item -ItemType Directory -Force -Path $logRoot | Out-Null
$log = Join-Path $logRoot ("WSB-{0}.log" -f (Get-Date -Format 'yyyyMMdd-HHmmss'))
Start-Transcript -Path $log -Append | Out-Null

try {
$flags = @()
if ($AllCritical) { $flags += '-allCritical' }
if ($VssFull)     { $flags += '-vssFull' }

$cmd = @(
'wbadmin', 'start', 'backup',
"-backupTarget:$Target",
"-include:$Include"
) + $flags + @('-quiet')

Write-Host ("[INFO] Démarrage sauvegarde: {0}" -f ($cmd -join ' '))
$proc = Start-Process -FilePath $cmd[0] -ArgumentList $cmd[1..($cmd.Length-1)] -NoNewWindow -Wait -PassThru
if ($proc.ExitCode -ne 0) { throw "wbadmin a retourné le code $($proc.ExitCode)" }

# Purge des versions: conserve les N dernières

$delCmd = "wbadmin delete backup -backupTarget:$Target -keepVersions:$KeepVersions -quiet"
Write-Host "[INFO] Purge des versions: $delCmd"
cmd.exe /c $delCmd | Write-Output

Write-Host "[OK] Sauvegarde et purge terminées."
}
catch {
Write-Error $_.Exception.Message
exit 1
}
finally {
Stop-Transcript | Out-Null
}

Remarque : keepVersions agit par nombre de versions, pas par jours. Pour 14 jours, assurez-vous d’une seule sauvegarde par jour, ou utilisez la purge par date ci‑dessous.

2) Sauvegarde vers un partage réseau avec rétention « 14 jours » par date

Le principe : cibler un sous-dossier daté différent chaque jour pour empêcher l’écrasement, puis supprimer les dossiers plus anciens que 14 jours.

# Backup-WSB-UNC.ps1
# Exécuter en tant qu'Administrateur. L'utilisateur doit avoir accès en écriture au partage.
param(
  [string]$Root        = '\\NAS01\WSB\SRV-APP01', # Racine du dépôt côté NAS/serveur de fichiers
  [string]$Include     = 'C:,D:',
  [int]$RetentionDays  = 14,
  [switch]$AllCritical = $true,
  [switch]$VssFull     = $true
)

function Assert-Admin {
$id = [Security.Principal.WindowsIdentity]::GetCurrent()
$p = New-Object Security.Principal.WindowsPrincipal($id)
if (-not $p.IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)) {
throw "Exécutez ce script en tant qu'Administrateur."
}
}

Assert-Admin

# 1) Créer le sous-dossier daté (YYYY-MM-DD)

$stamp = Get-Date -Format 'yyyy-MM-dd'
$target = Join-Path $Root $stamp
New-Item -ItemType Directory -Force -Path $target | Out-Null

# 2) Lancer la sauvegarde vers ce sous-dossier

$flags = @()
if ($AllCritical) { $flags += '-allCritical' }
if ($VssFull)     { $flags += '-vssFull' }

$cmd = @(
'wbadmin','start','backup',
"-backupTarget:$target",
"-include:$Include"
) + $flags + @('-quiet')

Write-Host ("[INFO] Démarrage sauvegarde: {0}" -f ($cmd -join ' '))
$proc = Start-Process -FilePath $cmd[0] -ArgumentList $cmd[1..($cmd.Length-1)] -NoNewWindow -Wait -PassThru
if ($proc.ExitCode -ne 0) { throw "wbadmin a retourné le code $($proc.ExitCode)" }

# 3) Purge des dossiers datés > RetentionDays

$limit = (Get-Date).AddDays(-$RetentionDays)
Get-ChildItem -Directory $Root |
Where-Object {
$*.Name -match '^\d{4}-\d{2}-\d{2}$' -and $*.LastWriteTime -lt $limit
} |
Sort-Object LastWriteTime |
ForEach-Object {
Write-Host "[INFO] Suppression: $($*.FullName)"
Remove-Item $*.FullName -Recurse -Force
}

Write-Host "[OK] Sauvegarde UNC terminée. Retention: $RetentionDays jours."

Bonnes pratiques :

Créez un compte de service dédié (lecture/écriture) pour le partage.
Ne faites jamais tourner la purge en même temps que la sauvegarde.
Journalisez (transcript) et conservez les logs ≥ 60 jours.

3) Rétention pour l’état du système

# Sauvegarde de l'état du système vers F:
wbadmin start systemstatebackup -backupTarget:F: -quiet

# Conserver 14 versions d'état du système

wbadmin delete systemstatebackup -keepVersions:14 -backupTarget:F: -quiet

Planification avec le Planificateur de tâches

Création côté interface

Ouvrez Planificateur de tâches → Créer une tâche.
Onglet Général : exécuter avec les autorisations maximales, utiliser un compte de service.
Onglet Déclencheurs : Quotidien, heure fixe (ex. 21:00).
Onglet Actions : Program/script : powershell.exe — Arguments : -NoProfile -ExecutionPolicy Bypass -File "C:\Scripts\Backup-WSB-UNC.ps1".
Onglet Conditions : décocher « arrêter si l’ordinateur passe en veille » pour les serveurs.
Créez un 2ᵉ job « Purge » décalé (ex. 23:30) qui appelle uniquement la partie nettoyage (ou le même script avec un paramètre -PurgeOnly si vous l’avez prévu).

Création en ligne de commande

# Tâche Sauvegarde quotidienne
schtasks /create /tn "WSB-Sauvegarde" /sc daily /st 21:00 /ru "DOMAINE\SVC_Backup" /rp "MotDePasseIci" /rl HIGHEST ^
 /tr "PowerShell.exe -NoProfile -ExecutionPolicy Bypass -File C:\Scripts\Backup-WSB-UNC.ps1"

# Tâche Purge quotidienne (répertoire réseau)

schtasks /create /tn "WSB-Purge" /sc daily /st 23:30 /ru "DOMAINE\SVC_Backup" /rp "MotDePasseIci" /rl HIGHEST ^
/tr "PowerShell.exe -NoProfile -ExecutionPolicy Bypass -Command "`$limit=(Get-Date).AddDays(-14); Get-ChildItem -Directory '\\NAS01\WSB\SRV-APP01' ^| ?{`$_.Name -match '^\d{4}-\d{2}-\d{2}$' -and `$_.LastWriteTime -lt `$limit} ^| Remove-Item -Recurse -Force""

Commandes de contrôle indispensables

Lister les versions : wbadmin get versions
Vérifier le contenu d’une version : wbadmin get items -version:<horodatage>
Supprimer une version précise : wbadmin delete backup -version:<horodatage> -backupTarget:<cible> -quiet
Journaux d’exécution : Observateur d’événements → Applications and Services Logs → Microsoft → Windows → Backup → Operational. Exemple rapide :
Get-WinEvent -LogName 'Microsoft-Windows-Backup/Operational' -MaxEvents 30 | Format-Table TimeCreated, Id, LevelDisplayName, Message -Auto

Dimensionner l’espace pour « 14 jours »

WSB réalise un premier full puis des incrémentiels (sur disque dédié). Pour estimer la taille utile :

Capacité ≈ (Full initial + (Jours-1 × Changement quotidien)) × marge 20–30 %

Exemple : vous sauvegardez 1 To de données, et 3 % changent chaque jour. Pour 14 jours :

Full : 1 To.
Incrémentiels : 13 × 30 Go ≈ 390 Go.
Marge 25 % : (1 To + 390 Go) × 1,25 ≈ 1,74 To.

Sur un partage réseau (où chaque exécution produit un nouveau dossier complet), la capacité doit couvrir 14 jeux complets, sauf si vos jeux sont limités aux volumes réellement modifiés (et qu’un autre outil fait la déduplication).

Bonnes pratiques de sécurité et de fiabilité

Chiffrement au repos : activez BitLocker sur le disque de sauvegarde. Pour un partage, sécurisez le stockage sous-jacent et, si nécessaire, l’SMB Encryption.
Déduplication : sur le volume cible (Windows Server 2022), pour économiser l’espace. Validez la compatibilité avec votre charge.
Isolation des droits : utilisez un compte de service à privilèges minimaux, sans droits interactifs.
Tests de restauration réguliers : fichiers, dossiers, voire restauration nue (bare metal) en environnement de labo.
Alerting : surveillez les échecs via événements. Exemple :
Get-WinEvent -LogName 'Microsoft-Windows-Backup/Operational' | Where-Object Id -in 5,9,17

FAQ express

Q : keepVersions:14 me garantit-il 14 jours ?
R : Non, il garantit 14 versions. Si vous lancez deux sauvegardes par jour, vous couvrirez 7 jours. Pour une rétention « calendaire », purgez par date.

Q : Sur un partage UNC, pourquoi mes sauvegardes s’écrasent‑elles ?
R : Par défaut, WSB ne garde qu’un jeu par chemin. Donnez chaque jour un chemin cible différent (dossier daté), puis purgez les anciens dossiers.

Q : Puis-je mélanger keepVersions et purge par date ?
R : Oui, par exemple : keepVersions pour l’état du système + purge par date pour les sauvegardes sur partage.

Q : Où se trouvent mes sauvegardes ?
R : WSB crée WindowsImageBackup\<NomDuServeur> sur la cible (disque ou dossier daté côté partage), avec des sous-dossiers de versions horodatées.

Q : Comment vérifier rapidement la dernière sauvegarde ?
R : wbadmin get versions puis wbadmin get items -version:<horodatage>. Vous pouvez aussi lire les derniers événements du journal WSB.

Checklist « 14 jours » prête à l’emploi

Choisissez la cible : disque dédié (simple et efficace) ou partage réseau (flexible, exige un script de rotation).
Créez un compte de service et un répertoire racine côté cible (ex. \\NAS01\WSB\SRV-APP01).
Déployez le script adapté (disque ou UNC) dans C:\Scripts.
Planifiez la sauvegarde quotidienne (ex. 21:00) et la purge (ex. 23:30).
Activez BitLocker (disque) ou durcissez le partage (ACL, SMB Signing/Encryption).
Dimensionnez la capacité pour 14 jours + marge.
Installez une surveillance : alertes sur échec, seuil d’espace libre.
Testez une restauration mensuelle (fichier + version système si applicable).

Exemples « copier‑coller »

One‑liner de purge par date (dossier local)

$limit = (Get-Date).AddDays(-14); Get-ChildItem 'E:\Backups' | Where-Object {$_.LastWriteTime -lt $limit} | Remove-Item -Recurse -Force

One‑liner de purge par date (partage UNC)

$limit = (Get-Date).AddDays(-14); Get-ChildItem -Directory '\\NAS01\WSB\SRV-APP01' | ? { $_.Name -match '^\d{4}-\d{2}-\d{2}$' -and $_.LastWriteTime -lt $limit } | Remove-Item -Recurse -Force

Informations complémentaires utiles

Lister les versions existantes : wbadmin get versions
Vérifier l’intégrité d’une version : wbadmin get items -version:<horodatage>
Sauvegarde sur partage réseau : chaque exécution crée un dossier complet sous le chemin cible ; sans rotation de chemin, le dernier jeu peut remplacer l’ancien. La rotation par dossier daté évite l’écrasement.
Tester la restauration à intervalles réguliers afin de s’assurer que la purge n’élimine pas des sauvegardes encore nécessaires.

Modèle de politique écrite (à coller dans votre runbook)

Objectif: conserver 14 jours d'historique des sauvegardes Windows Server Backup 2022 (fichiers/volumes et état du système).
Cible: partage \\NAS01\WSB\SRV-APP01 avec dossiers quotidiens YYYY-MM-DD + disque F: pour System State.
Fréquence: 1 sauvegarde par jour à 21:00.
Rétention:
 - Dossiers quotidiens > 14 jours: supprimés automatiquement (purge PowerShell).
 - État du système: keepVersions:14.
Sécurité: BitLocker sur les disques externes; contrôle d'accès NTFS/SMB strict; compte de service dédié.
Surveillance: alertes en cas d'échec WSB; seuil espace libre < 15%.
Tests: restauration fichier chaque mois; restauration bare-metal en labo chaque trimestre.
Responsabilités: Ops sauvegarde pilote; validation par Responsable Exploitation.

Conclusion

Conserver 14 jours d’historique avec Windows Server Backup 2022 est simple dès que l’on respecte la logique de WSB : par versions sur disque dédié (avec keepVersions) et par date sur partage réseau (dossiers datés + script de purge). En ajoutant la planification, la surveillance et des tests de restauration, vous obtenez une chaîne de sauvegarde robuste, vérifiable et prête à affronter les incidents du quotidien.

Windows Server Backup 2022 : configurer une rétention de 14 jours (wbadmin, PowerShell, planification)