web-dev-qa-db-fra.com

Comment utiliser une copie d'ombre volume pour faire des sauvegardes

Le plan consiste à créer une copie d'ombre d'un volume assez volumineux, I/O-Heavy. Il est 350 Go, contenant un indice FULTLEXT basé sur un système de fichiers organisé dans des centaines de dossiers et des centaines de milliers de fichiers minuscules qui doivent être dans un état cohérent pour une restauration réussie.

Actuellement, l'indexeur est arrêté, la tâche de sauvegarde fonctionne, puis l'indexeur est redémarré. Cela se traduit par l'index étant indisponible pendant des heures pendant la sauvegarde. J'aimerais effectuer des sauvegardes cohérentes via une copie Shadow, idéalement sans avoir à arrêter l'indexeur du tout.

Ainsi, j'ai activé la copie de l'ombre pour ce volume et la configurée pour effectuer un instantané une fois par nuit, à un volume différent.

Maintenant, je suis un peu à perte - comment puis-je accéder à la copie de l'ombre dans son ensemble, afin que je puisse faire une sauvegarde? J'envisage d'un lecteur en lecture seule contenant les fichiers tels qu'ils étaient à l'époque du dernier instantané, mais peut-être que les choses fonctionnent totalement différent.

OS est Windows Server 2003 SP2, le logiciel de sauvegarde est la commvault Galaxy 7.0.

[~ # ~] Edit [~ # ~]: Notez que - Entre-temps - deux réponses ont été créées qui implémentent la fonctionnalité nécessaire sous la forme d'un script:

windows-server-2003backupvss
11
Tomalak

Alors ... je travaille sur un petit VBScript qui peut:

  • prenez des instantanés persistants vsss
  • montez-les dans un dossier (à partir duquel vous pouvez ensuite sauvegarder les fichiers)
  • démonter les instantanés VSS

Il repose sur vshadow.exe ( documentation ), une partie du Volume Shadow Copy Service SDK 7.2 Aussi disponible chez Microsoft. Je travaille avec cette version: " vshadow.exe 2.2 - Exemple d'échantillon de copie de l'ombre de volume, copyright (c) 2005 Microsoft Corporation. "

Fondamentalement, il s'agit d'une petite enveloppe nette autour de ces quatre commandes Vshadow:

 vshadow.exe -q - liste toutes les copies de l'ombre dans le système [.____] vshadow.exe -p {Liste de volumes} - gère des copies ombres persistantes 
 vshadow.exe -el = {Snapid }, Dir - expose la copie ombre comme point de montage 
 vshadow.exe -ds = {snapide} - supprime cette copie ombragée [.____]

Voici son écran d'aide:

 Snapshot VSS Créer/Mount Tool [.____] 
 Usage: [/Unmount} [/debug]

/volume - lettre de lecteur du volume à l'instantané [.____]/cible - le chemin (absolu ou relatif) pour monter l'instantané sur 
/débogage - Swich sur la sortie de débogage 
 
 Exemples: [.____] CScript/nologo vsssnapshot.vbs/cible: C:\Sauvegarde\Cordialement cscript/nologo vsssnapshot.vbs/cible: C:\Backup\Cordialement /unmount
Hint: Pas besoin de démonter avant de prendre un nouvel instantané. [.____]

Voici quelques échantillons de sortie:

[ ____ ____] 05/03/2010 17:13:08 Snapshot créé avec ID: {4ED3A907-C66F-4B20-BDA0-9DCDA3B667EC} [ ____ 03/2010 17:13:35 Préparer le point de montage VSS ... 
 05/03/2010 17:13:36 rien d'autre à faire 
 05/03/2010 17:13:36 Terminé

Et voici le script lui-même. L'avertissement habituel s'applique: le logiciel est fourni tel quel, je ne donne aucune garantie, à utiliser à vos risques et périls, si quelque chose enfreint le seul à blâmer, c'est vous-même. Je l'ai testé assez bien, cependant et cela fonctionne bien pour moi. N'hésitez pas à me prévenir de bugs via les commentaires ci-dessous.

''# VssSnapshot.vbs
''# http://serverfault.com/questions/119120/how-to-use-a-volume-shadow-copy-to-make-backups/119592#119592
Option Explicit

Dim fso: Set fso = CreateObject("Scripting.FileSystemObject")

''# -- MAIN SCRIPT -------------------------------------------
Dim args, snapshotId, targetPath, success
Set args = WScript.Arguments.Named
CheckEnvironment

Log "preparing VSS mount point..."
targetPath = PrepareVssMountPoint(args("target"))

If args.Exists("unmount") Then
  Log "nothing else to do"
ElseIf targetPath <> vbEmpty Then
  Log "mount point prepared at: " & targetPath
  Log "creating VSS snapshot for volume: " & args("volume")
  snapshotId = CreateVssSnapshot(args("volume"))

  If snapshotId <> vbEmpty Then
    Log "snapshot created with ID: " & snapshotId
    success = MountVssSnapshot(snapshotId, targetPath)
    If success Then
      Log "VSS snapshot mounted sucessfully"
    Else
      Die "failed to mount snapshot"
    End If
  Else
    Die "failed to create snapshot"
  End If
Else
  Die "failed to prepare mount point"
End If

Log "finished"

''# -- FUNCTIONS ---------------------------------------------
Function PrepareVssMountPoint(target) ''# As String
  Dim cmd, result, outArray
  Dim path, snapshot, snapshotId
  Dim re, matches, match

  PrepareVssMountPoint = VbEmpty
  target = fso.GetAbsolutePathName(target)

  If Not fso.FolderExists(fso.GetParentFolderName(target)) Then 
    Die "Invalid mount point: " & target
  End If

  ''# create or unmount (=delete existing snapshot) mountpoint
  If Not fso.FolderExists(target) Then
    If Not args.Exists("unmount") Then fso.CreateFolder target
  Else
    Set re = New RegExp
    re.MultiLine = False
    re.Pattern = "- Exposed locally as: ([^\r\n]*)"

    cmd = "vshadow -q"
    result = RunCommand(cmd, false)
    outarray = Split(result, "*")

    For Each snapshot In outArray
      snapshotId = ParseSnapshotId(snapshot)
      If snapshotId <> vbEmpty Then
        Set matches = re.Execute(snapshot)
        If matches.Count = 1 Then
          path = Trim(matches(0).SubMatches(0))
          If fso.GetAbsolutePathName(path) = target Then
            cmd = "vshadow -ds=" & snapshotId
            RunCommand cmd, true
            Exit For
          End If
        End If
      End If
    Next

    If args.Exists("unmount") Then fso.DeleteFolder target
  End If

  PrepareVssMountPoint = target
End Function

Function CreateVssSnapshot(volume) ''# As String
  Dim cmd, result

  If Not fso.DriveExists(volume) Then
    Die "Drive " & volume & " does not exist."
  End If

  cmd = "vshadow -p " & Replace(UCase(volume), ":", "") & ":"
  result = RunCommand(cmd, false)
  CreateVssSnapshot = ParseSnapshotId(result)
End Function

Function MountVssSnapshot(snapshotId, target) ''# As Boolean
  Dim cmd, result

  If fso.FolderExists(targetPath) Then
    cmd = "vshadow -el=" & snapshotId & "," & targetPath
    result = RunCommand(cmd, true)
  Else
    Die "Mountpoint does not exist: " & target
  End If

  MountVssSnapshot = (result = "0")
End Function

Function ParseSnapshotId(output) ''# As String
  Dim re, matches, match

  Set re = New RegExp
  re.Pattern = "SNAPSHOT ID = (\{[^}]{36}\})"
  Set matches = re.Execute(output)

  If matches.Count = 1 Then
    ParseSnapshotId = matches(0).SubMatches(0)
  Else
    ParseSnapshotId = vbEmpty
  End If
End Function

Function RunCommand(cmd, exitCodeOnly) ''# As String
  Dim Shell, process, output

  Dbg "Running: " & cmd

  Set Shell = CreateObject("WScript.Shell")

  On Error Resume Next
  Set process = Shell.Exec(cmd)
  If Err.Number <> 0 Then
    Die Hex(Err.Number) & " - " & Err.Description
  End If
  On Error GoTo 0

  Do While process.Status = 0
    WScript.Sleep 100
  Loop
  output = Process.StdOut.ReadAll

  If process.ExitCode = 0 Then 
    Dbg "OK"
    Dbg output
  Else
    Dbg "Failed with ERRORLEVEL " & process.ExitCode
    Dbg output
    If Not process.StdErr.AtEndOfStream Then 
      Dbg process.StdErr.ReadAll
    End If
  End If  

  If exitCodeOnly Then
    Runcommand = process.ExitCode
  Else
    RunCommand = output
  End If
End Function

Sub CheckEnvironment
  Dim argsOk

  If LCase(fso.GetFileName(WScript.FullName)) <> "cscript.exe" Then
    Say "Please execute me on the command line via cscript.exe!"
    Die ""
  End If

  argsOk = args.Exists("target")
  argsOk = argsOk And (args.Exists("volume") Or args.Exists("unmount"))

  If Not argsOk Then
    Say "VSS Snapshot Create/Mount Tool" & vbNewLine & _
        vbNewLine & _
        "Usage: " & vbNewLine & _
        "cscript /nologo " & fso.GetFileName(WScript.ScriptFullName) & _
          " /target:path { /volume:X | /unmount } [/debug]" & _
        vbNewLine & vbNewLine & _
        "/volume  - drive letter of the volume to snapshot" & _
        vbNewLine & _
        "/target  - the path (absolute or relative) to mount the snapshot to" & _
        vbNewLine & _
        "/debug   - swich on debug output" & _
        vbNewLine & vbNewLine & _
        "Examples: " & vbNewLine & _
        "cscript /nologo " & fso.GetFileName(WScript.ScriptFullName) & _
          " /target:C:\Backup\DriveD /volume:D" &  vbNewLine & _
        "cscript /nologo " & fso.GetFileName(WScript.ScriptFullName) & _
          " /target:C:\Backup\DriveD /unmount" & _
        vbNewLine & vbNewLine & _
        "Hint: No need to unmount before taking a new snapshot." & vbNewLine

    Die ""
  End If
End Sub

Sub Say(message)
  If message <> "" Then WScript.Echo message
End Sub

Sub Log(message)
  Say FormatDateTime(Now()) & " " & message
End Sub

Sub Dbg(message)
  If args.Exists("debug") Then 
    Say String(75, "-")
    Say "DEBUG: " & message
  End If
End Sub

Sub Die(message)
  If message <> "" Then Say "FATAL ERROR: " & message
  WScript.Quit 1
End Sub

J'espère que cela aide quelqu'un. N'hésitez pas à l'utiliser conformément à CC-BY-SA . Tout ce que je demande, c'est que vous laissez le lien intact qui repère ici.

9
Tomalak

Donc, dans l'esprit de réinventer la roue, je présente à votre excellent script de Tomalak (voir ci-dessus) mais complètement réécrit dans PowerShell !!! La raison principale que je faisais c'était pour évangéliser les pouvoirs impressionnants de PowerShell, mais aussi parce que je méprise Vbscript avec tout mon être.

Il s'agit principalement de la fonctionnalité identique, mais j'ai mis en œuvre certaines choses un peu différemment pour diverses raisons. La sortie de débogage est définitivement plus verbeuse.

Une chose très importante à noter est que cette version détecte la version du système d'exploitation et la bitness et appelle la version appropriée de Vshadow.exe. J'ai inclus un graphique ci-dessous pour montrer quelles versions de Vshadow.exe à utiliser, où les obtenir et quoi les nommer.

Voici les informations d'utilisation:

VssSnapshot.ps1

Description:
  Create, mount or delete a Volume Shadow Copy Service (VSS) Shadow Copy (snapshot)

Usage:
  VssSnapshot.ps1 Create -Target <Path> -Volume <Volume> [-Debug]
  VssSnapshot.ps1 Delete -Target <Path> [-Debug]

Paremeters:
  Create  - Create a snapshot for the specified volume and mount it at the specified target
  Delete  - Unmount and delete the snapshot mounted at the specified target
  -Target - The path (quoted string) of the snapshot mount point
  -Volume - The volume (drive letter) to snapshot
  -Debug  - Enable debug output (optional)

Examples:
  VssSnapshot.ps1 Create -Target D:\Backup\DriveC -Volume C
  - Create a snapshot of volume C and mount it at "D:\Backup\DriveC"

  VssSnapshot.ps1 Delete -Target D:\Backup\DriveC
  - Unmount and delete a snapshot mounted at "D:\Backup\DriveC"

Advanced:
  VssSnapshot.ps1 create -t "c:\vss mount\c" -v C -d
  - Create a snapshot of volume C and mount it at "C:\Vss Mount\C"
  - example mounts snapshot on source volume (C: --> C:)
  - example uses shortform parameter names
  - example uses quoted paths with whitespace
  - example includes debug output

Voici le script:

# VssSnapshot.ps1
# http://serverfault.com/questions/119120/how-to-use-a-volume-shadow-copy-to-make-backups/119592#119592

Param ([String]$Action, [String]$Target, [String]$Volume, [Switch]$Debug)
$ScriptCommandLine = $MyInvocation.Line
$vshadowPath = "."

# Functions
Function Check-Environment {
  Write-Dbg "Checking environment..."

  $UsageMsg = @'
VssSnapshot

Description:
  Create, mount or delete a Volume Shadow Copy Service (VSS) Shadow Copy (snapshot)

Usage:
  VssSnapshot.ps1 Create -Target <Path> -Volume <Volume> [-Debug]
  VssSnapshot.ps1 Delete -Target <Path> [-Debug]

Paremeters:
  Create  - Create a snapshot for the specified volume and mount it at the specified target
  Delete  - Unmount and delete the snapshot mounted at the specified target
  -Target - The path (quoted string) of the snapshot mount point
  -Volume - The volume (drive letter) to snapshot
  -Debug  - Enable debug output (optional)

Examples:
  VssSnapshot.ps1 Create -Target D:\Backup\DriveC -Volume C
  - Create a snapshot of volume C and mount it at "D:\Backup\DriveC"

  VssSnapshot.ps1 Delete -Target D:\Backup\DriveC
  - Unmount and delete a snapshot mounted at "D:\Backup\DriveC"

Advanced:
  VssSnapshot.ps1 create -t "c:\vss mount\c" -v C -d
  - Create a snapshot of volume C and mount it at "C:\Vss Mount\C"
  - example mounts snapshot on source volume (C: --> C:)
  - example uses shortform parameter names
  - example uses quoted paths with whitespace
  - example includes debug output
'@

  If ($Action -eq "Create" -And ($Target -And $Volume)) {
    $Script:Volume = (Get-PSDrive | Where-Object {$_.Name -eq ($Volume).Substring(0,1)}).Root
    If ($Volume -ne "") {
      Write-Dbg "Verified volume: $Volume"
    } Else {
      Write-Dbg "Cannot find the specified volume"
      Exit-Script "Cannot find the specified volume"
    }
    Write-Dbg "Argument check passed"
  } ElseIf ($Action -eq "Delete" -And $Target ) {
    Write-Dbg "Argument check passed"
  } Else {
    Write-Dbg "Invalid arguments: $ScriptCommandLine"
    Exit-Script "Invalid arguments`n`n$UsageMsg"
  }


  $WinVer = ((Get-WmiObject Win32_OperatingSystem).Version).Substring(0,3)
    Switch ($WinVer) {
    "5.2" {
      $vshadowExe = "vshadow_2003"
      $WinBit = ((Get-WmiObject Win32_Processor)[0]).AddressWidth
    }
    "6.0" {
      $vshadowExe = "vshadow_2008"
      $WinBit = (Get-WmiObject Win32_OperatingSystem).OSArchitecture
    }
    "6.1" {
      $vshadowExe = "vshadow_2008R2"
      $WinBit = (Get-WmiObject Win32_OperatingSystem).OSArchitecture
    }
    Default {
      Write-Dbg "Unable to determine OS version"
      Exit-Script "Unable to determine OS version"
    }
  }

  Switch ($WinBit) {
    {($_ -eq "32") -or ($_ -eq "32-bit")} {$vshadowExe += "_x86.exe"}
    {($_ -eq "64") -or ($_ -eq "64-bit")} {$vshadowExe += "_x64.exe"}
    Default {
      Write-Dbg "Unable to determine OS bitness"
      Exit-Script "Unable to determine OS bitness"
    }
  }

  $Script:vshadowExePath = Join-Path $vshadowPath $vshadowExe
  If (Test-Path $vshadowExePath) {
    Write-Dbg "Verified vshadow.exe: $vshadowExePath"
  } Else {
    Write-Dbg "Cannot find vshadow.exe: $vshadowExePath"
    Exit-Script "Cannot find vshadow.exe"
  }

  Write-Dbg "Environment ready"
}

Function Prepare-Target {
  Write-Log "Preparing target..."
  Write-Dbg "Preparing target $Target"


  If (!(Test-Path (Split-Path $Target -Parent))) {
  Write-Dbg "Target parent does not exist"
  Exit-Script "Invalid target $Target"
  }
  If ((Test-Path $Target)) {
    Write-Dbg "Target already exists"
    If (@(Get-ChildItem $Target).Count -eq 0) {
      Write-Dbg "Target is empty"
    } Else {
      Write-Dbg "Target is not empty"
      Exit-Script "Target contains files/folders"
    }
  } Else {
    Write-Dbg "Target does not exist. Prompting user..."
    $PromptYes = New-Object System.Management.Automation.Host.ChoiceDescription "&Yes", "Create target folder"
    $PromptNo = New-Object System.Management.Automation.Host.ChoiceDescription "&No", "Do not create target folder"
    $PromptOptions = [System.Management.Automation.Host.ChoiceDescription[]]($PromptYes, $PromptNo)
    $PromptResult = $Host.UI.PromptForChoice("Create folder", "The target folder `"$target`" does not exist.`nWould you like to create the folder?", $PromptOptions, 0) 
    Switch ($PromptResult) {
      0 {
        Write-Dbg "User Accepted. Creating target..."
        $Null = New-Item -Path (Split-Path $Target -Parent) -Name (Split-Path $Target -Leaf) -ItemType "Directory"
      }
      1 {
        Write-Dbg "User declined. Exiting..."
        Exit-Script "Target does not exist"
      }
    }
  }
  Write-Log "Target ""$Target"" ready"
  Write-Dbg """$Target"" ready"
}

Function Create-Snapshot {
  Write-Log "Creating snapshot..."
  Write-Dbg "Creating snapshot of $Volume"
  $Cmd = "$vshadowExePath -p $Volume"
  $CmdResult = Run-Command $Cmd -AsString

  Write-Dbg "Snapshot created successfully"

  $SnapshotID = $CmdResult -Match 'SNAPSHOT ID = (\{[^}]{36}\})'
  If ($SnapshotID) {
    $SnapshotID = $Matches[1]
    Write-Dbg "SnapshotID: $SnapshotID"
    Write-Log "Snapshot $SnapshotID created"
  } Else {
    Write-Dbg "Unable to determine SnapshotID"
    Exit-Script "Unable to determine SnapshotID"
  }

  Return $SnapshotID
}

Function Mount-Snapshot ($SnapshotID) {
  Write-Log "Mounting snapshot..."
  Write-Dbg "Mounting $SnapshotID at ""$Target"""

  $Cmd = "$vshadowExePath `"-el=$SnapshotId,$Target`"" #Must use escaped quotes because Invoke-Expression gets all weird about curly braces
  $CmdResult = Run-Command $Cmd

  Write-Log "Snapshot $SnapshotID mounted at target ""$Target"""
  Write-Dbg "$SnapshotID mounted at ""$Target"""
}

Function Delete-Snapshot {
  Write-Log "Deleting snapshot..."
  Write-Dbg "Deleting snapshot at target ""$Target"""

  $SnapshotID = Get-SnapshotIdbyTarget

  $Cmd = "$vshadowExePath `"-ds=$SnapshotId`""
  $CmdResult = Run-Command $Cmd

  Write-Log "Snapshot $SnapshotID deleted at target ""$Target"""
  Write-Dbg "$SnapshotID deleted at ""$Target"""
}

Function Get-SnapshotIdbyTarget {
  Write-Dbg "Finding SnapshotID for $Target"

  $Cmd = "$vshadowExePath -q"
  $CmdResult = Run-Command $Cmd -AsString

  $TargetRegEx = '(?i)' + $Target.Replace('\','\\') + '\\?\r'
  $Snapshots = ($CmdResult.Split('*')) -Match $TargetRegEx | Out-String

  If ($Snapshots) {
    $Null = $Snapshots -Match '(\{[^}]{36}\})'
    $SnapshotID = $Matches[0]
  } Else {
    Write-Dbg "Unable to determine SnapshotID for target $Target"
    Exit-Script "Unable to determine SnapshotID"
  }  

  Write-Dbg "SnapshotID: $SnapshotID"

  Return $SnapshotID
}

Function Run-Command ([String]$Cmd, [Switch]$AsString=$False, [Switch]$AsArray=$False) {
  Write-Dbg "Running: $Cmd"

  $CmdOutputArray = Invoke-Expression $Cmd
  $CmdOutputString = $CmdOutputArray | Out-String
  $CmdErrorCode = $LASTEXITCODE

  If ($CmdErrorCode -eq 0 ) {
    Write-Dbg "Command successful. Exit code: $CmdErrorCode"
    Write-Dbg $CmdOutputString
  } Else {
    Write-Dbg "Command failed. Exit code: $CmdErrorCode"
    Write-Dbg $CmdOutputString
    Exit-Script "Command failed. Exit code: $CmdErrorCode"
  }

  If (!($AsString -or $AsArray)) {
    Return $CmdErrorCode
  } ElseIf ($AsString) {
    Return $CmdOutputString
  } ElseIf ($AsArray) {
    Return $CmdOutputArray
  }
}

Function Write-Msg ([String]$Message) {
  If ($Message -ne "") {
    Write-Host $Message
  }
}

Function Write-Log ([String]$Message) {
  Write-Msg "[$(Get-Date -Format G)] $Message"
}

Function Write-Dbg ([String]$Message) {
  If ($Debug) {
    Write-Msg ("-" * 80)
    Write-Msg "[DEBUG] $Message"
    Write-Msg ("-" * 80)
  }
}

Function Exit-Script ([String]$Message) {
  If ($Message -ne "") {
    Write-Msg "`n[FATAL ERROR] $Message`n"
  }
  Exit 1
}

# Main
Write-Log "VssSnapshot started"
Check-Environment

Switch ($Action) {
  "Create" {
    Prepare-Target
    $SnapshotID = Create-Snapshot
    Mount-Snapshot $SnapshotID
  }
  "Delete" {
    Delete-Snapshot
  }
}

Write-Log "VssSnapshot finished"

Voici les versions Vshadow.exe à utiliser:

  1. Windows 2003/2003R2 [.____]
    • Volume Shadow Copy Service SDK 7.2
    • x86: C:\Fichiers de programme\Microsoft\vsssdk72\Testapps\vshadow\bin\Livrer-serveur\vshadow.exe
      • Renommer à: vshadow_2003_x86.exe
    • x64: Je n'ai pas été en mesure de localiser une version x64 de Vshadow.exe pour Windows 2003 x64
  2. Windows 2008
    • Windows SDK pour Windows Server 2008 et .NET Framework 3.5
    • x86: C:\Fichiers de programme\Microsoft sdks\Windows\V6.1\bin\vstools\vshadow.exe [.____]
      • Renommer à: vshadow_2008_x86.exe
    • x64: C:\Fichiers de programme\Microsoft sdks\Windows\v6.1\bin\x64\vstools\vshadow.exe [.____]
      • Renommer à: vshadow_2008_x64.exe
  3. Windows 2008R2 [.____]
    • Microsoft Windows SDK pour Windows 7 et .NET Framework 4
    • x86: C:\Fichiers du programme (x86)\Microsoft sdks\Windows\v7.0a\bin\vstools\vshadow.exe [.____]
      • Renommer à: vshadow_2008r2_x86.exe
    • x64: C:\Fichiers du programme (x86)\microsoft sdks\windows\v7.0a\bin\x64\vstools\vshadow.exe [.____]
      • Renommer à: vshadow_2008r2_x64.exe
10
John Homer
  1. Utilisez la commande vssadmin list shadows Pour répertorier toutes les copies ombres disponibles. Vous obtiendrez une sortie comme celle-ci ...
[.____] C: \> VSSADMIN List Shadows 
 Vssadmin 1.1 - Volume Shadow Copy Service Tool de ligne de commande administrative [.____] (c) Copyright 2001 Microsoft Corp. 
 Contenu de la copie Shadow Copy ID: {B6F6FB45-Bedd-4B77-8F51-14292E9F51-14292EE921F3} [ Copier ID: {321930D4-0442-4CC6-B2AA-EC47F21D0EB1} [.____] Volume d'origine: (C :) \\?\Volume {AD1DD231-1200-11de-B1DF-806E6F6E6963}\
 Copie Shadow Volume: \\?\Globalroot\Appareil\HardDiskVolumenthadowCopopy68 [.____] Machine d'origine: JOSHWEB.JOSH.COM [ 1.0 '[.____] Type: Clientaccessible 
 Attributs: persistant, accessible au client, aucune libération automatique, aucun écrivain, différentiel [.____] 
 Contenu de la copie Shadow Copy ID: {C4FD8646 -57b3-4b39-be75-47dc8e7f881d} [.____] contenait 1 exemplaire d'ombre A T Création Temps: 8/25/2016 7:00:18 AM 
 Shadow Copy ID: {FA5DA100-5D90-493C-89B1-5C27874A23C6} 
 Volume d'origine: (E :) \\?\Volume {4ec17949-12b6-11de-8872-00235428b661}\[.____] Volume de copie d'ombre: \\?\Globalroot\Device\HardDiskVolUmetHadowcopy3 [.____]: Joshweb.josh.com [.____] Machine de service: joshweb.josh.com 
 Fournisseur: "Fournisseur de copie Shadow Microsoft Software 1.0 '[.____] Type: Clientaccessible 
 Attributs: persistant, accessible au client, aucune libération automatique, aucun écrivain , Différentiel [.____] 
 C:\[.____]

  1. Noter la Shadow Copy Volume Nom pour la copie de l'ombre que vous voulez (le plus facile au presse-papiers).

  2. Montez la copie de l'ombre

Sous Windows 2003 ...

Vous devrez télécharger les Outils de kit de ressources pour 20 Si vous ne l'avez pas déjà.

Entrez la commande ...

 Linkd C:\Shadow \\?\Globalroot\Device\HardDiskVolumentShadowCopy69\[.____]

...où c:\shadow est le chemin où vous voulez que la copie de l'ombre apparaisse et \\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy69 est le nom que vous avez copié ci-dessus. Notez que vous devez ajoutez une barre oblique inverse à la fin de la copie de l'ombre!

Sous Windows 2008 et plus ...

Entrez la commande ...

[.____] Mklink C:\Shadow \\?\Globalroot\Appareil\HardDiskVolumentShadowCopy69\[.____]

...où c:\shadow est le chemin où vous voulez que la copie de l'ombre apparaisse et \\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy69 est le nom que vous avez copié ci-dessus. Notez que vous devez ajoutez une barre oblique inverse à la fin de la copie de l'ombre!

  1. Utilisez tout l'outil que vous souhaitez (y compris Windows Explorer ou XCOPY) pour accéder aux fichiers de c:\shadow.
6
Will V

J'espère que c'est ce que vous voulez:

dISKSHADOW -S VSSSBACKUP.CFG

vsssbackup.cfg:

set context persistent
set metadata E:\backup\result.cab
set verbose on
begin backup
     add volume C: alias ConfigVolume
     create
     EXPOSE %ConfigVolume% Y:
     # Y is your VSS drive
     # run your backup script here
     delete shadows exposed Y:
end backup
2
jackbean

Vous êtes mal compris que VSS fonctionne avec le système de fichiers (comment cela fonctionne avec des bases de données est complètement différent). Sur le système de fichiers, VSS est utilisé pour implémenter la fonctionnalité "Versions précédentes", qui est uniquement utilisée pour instantané modifications vers des fichiers et des dossiers à des points prédéfinis à temps pour la récupération via l'onglet Versions précédentes des clients. Ces modifications sont ensuite fusionnées avec les données sur le volume de la construction de l'ensemble de récupération. Cela dépend donc du volume d'origine étant toujours là afin d'effectuer la récupération, ce qui est en d'autres termes inutiles aux fins de la sauvegarde et de la restauration appropriées.

Je pense que vous devez reculer de la façon dont vous voulez faire cela et de réfléchir à ce que vous voulez faire.

350 Go de données ne sont pas beaucoup vraiment, et je suis disposé à parier que le pourcentage de ce qui soit activement utilisé au quotidien est assez faible. Avez-vous envisagé de faire des sauvegardes différentielles sur la nuit avec des sauvegardes complètes uniquement les week-ends? Ou à l'aide de la réplication DFS planifiée sur le stockage alternatif afin d'obtenir un "instantané" (qui est ensuite sauvegardé)?

2
Maximus Minimus

En utilisant l'API VSS, il est possible de prendre un "instantané" du volume. Ensuite, vous devez monter cet instantané afin de copier. Je connais un produit désormais mortique qui a utilisé cette technique pour reproduire des données malgré les fichiers ouverts exclusivement par d'autres processus du système de fichiers en direct. Des questions valides peuvent être soulevées sur la question de savoir si les fichiers de l'instantané VSS sont auto-cohérents s'ils sont écrits par des applications qui ne sont pas intégrées à l'API de VSS. Il peut y avoir d'autres produits offrant des capacités similaires.

0
Fred