Come utilizzare una copia shadow del volume per eseguire i backup


11

Il piano è quello di creare una copia shadow di un volume piuttosto grande, I / O pesante. È 350 GB, contenente un indice full-text basato su filesystem organizzato in centinaia di cartelle e centinaia di migliaia di piccoli file che devono essere in uno stato coerente per un ripristino riuscito.

Attualmente l'indicizzatore viene arrestato, l'attività di backup viene eseguita e quindi l'indicizzatore viene riavviato. Ciò comporta che l'indice non sarà disponibile per ore durante il backup. Mi piacerebbe fare backup coerenti tramite copia shadow, idealmente senza mai interrompere l'indicizzatore.

Quindi, ho attivato Shadow Copy per quel volume e l'ho configurato per fare uno snapshot una volta ogni notte, a un volume diverso.

Ora sono un po 'perplesso: come posso accedere alla copia shadow nel suo complesso, in modo da poter effettuare un backup? Immagino un'unità di sola lettura che contenga i file come erano al momento dell'ultima istantanea, ma forse le cose funzionano in modo completamente diverso.

Il sistema operativo è Windows Server 2003 SP2, il software di backup è CommVault Galaxy 7.0.


EDIT : Nota che nel frattempo sono state create due risposte che implementano le funzionalità necessarie sotto forma di uno script:


La galassia commvault non utilizza già VSS per creare il backup? Ricordo vagamente che commvault è stato uno dei primi fornitori a implementare una soluzione di backup basata su VSS
Jim B

@Jim: Sì, ma solo per i file bloccati in base al file. Ciò di cui ho bisogno sono tutti i file sul disco in uno stato coerente. Ma questo non accadrà a meno che a) l'indicizzatore non venga eseguito o b) io abbia una copia di istantanea, come quelle che VSS può fare.
Tomalak

VSS non funziona così - è una copia shadow VOLUME. Se utilizza VSS, l'unica differenza è rappresentata dal fatto che il software di backup degli snap persistenti utilizza gli snap temporanei. Suppongo che un'applicazione potrebbe eseguire snapshot di eliminazione in base al file, ma non solo i backup sarebbero incoerenti, ma il tempo di backup anche di un'installazione di Windows predefinita sarebbe nell'ordine dei giorni. Vedere msdn.microsoft.com/en-us/library/aa384589(VS.85).aspx per un diagramma del funzionamento dell'elaborazione VSS. Vorrei contattare commvault e vedere se possono assicurarsi che la configurazione del backup sia corretta.
Jim B

Risposte:


10

Quindi, nello spirito di reinventare la ruota, vi presento l'eccellente sceneggiatura di Tomalak (vedi sopra) ma completamente riscritta in Powershell !!! Il motivo principale per cui ho fatto questo è stato quello di evangelizzare i fantastici poteri di Powershell, ma anche perché disprezzo vbscript con tutto il mio essere.

La funzionalità è principalmente identica, ma ho implementato alcune cose in modo leggermente diverso per vari motivi. L'output di debug è decisamente più dettagliato.

Una cosa molto importante da notare è che questa versione rileva la versione del sistema operativo e bitness e chiama la versione appropriata di vshadow.exe. Ho incluso un grafico qui sotto per mostrare quali versioni di vshadow.exe utilizzare, dove trovarle e come denominarle.


Ecco le informazioni sull'utilizzo:

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

Ecco la sceneggiatura:

# 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"

Ecco le versioni di vshadow.exe da utilizzare:

  1. Windows 2003 / 2003R2
    • SDK del servizio Copia Shadow del volume 7.2
    • x86: C: \ Programmi \ Microsoft \ VSSSDK72 \ TestApps \ vshadow \ bin \ release-server \ vshadow.exe
      • Rinomina in: vshadow_2003_x86.exe
    • x64: Non sono stato in grado di individuare una versione x64 di vshadow.exe per Windows 2003 x64
  2. Windows 2008
    • Windows SDK per Windows Server 2008 e .NET Framework 3.5
    • x86: C: \ Programmi \ Microsoft SDKs \ Windows \ v6.1 \ Bin \ vsstools \ vshadow.exe
      • Rinomina in: vshadow_2008_x86.exe
    • x64: C: \ Programmi \ Microsoft SDKs \ Windows \ v6.1 \ Bin \ x64 \ vsstools \ vshadow.exe
      • Rinomina in: vshadow_2008_x64.exe
  3. Windows 2008 R2
    • Microsoft Windows SDK per Windows 7 e .NET Framework 4
    • x86: C: \ Programmi (x86) \ Microsoft SDKs \ Windows \ v7.0A \ Bin \ vsstools \ vshadow.exe
      • Rinomina in: vshadow_2008R2_x86.exe
    • x64: C: \ Programmi (x86) \ Microsoft SDKs \ Windows \ v7.0A \ Bin \ x64 \ vsstools \ vshadow.exe
      • Rinomina in: vshadow_2008R2_x64.exe

2
btw ... Sono stato in grado di implementarlo come parte della nostra soluzione di backup utilizzando Arcserve come backup di file aperto di un uomo povero. È meglio che pagare $ 800 per server per la licenza agente. Se qualcuno è interessato, posterò qui.
John Homer,

+1 Questo è piuttosto sorprendente. Grazie per aver dedicato del tempo a portarlo su ps (nonostante il tuo odio per VBS) e per averlo condiviso qui. Spero che più persone lo troveranno utile, poiché ciò merita sicuramente più di un voto positivo.
Tomalak,

9

Quindi ... ho lavorato su un piccolo VBScript che può:

  • prendere istantanee VSS persistenti
  • montarli in una cartella (da cui è quindi possibile eseguire il backup dei file)
  • smonta snapshot VSS

Si basa su vshadow.exe( documentazione ), parte di Volume Shadow Copy Service SDK 7.2 come disponibile da Microsoft. Ho lavorato con questa versione: " VSHADOW.EXE 2.2 - Client di esempio Copia Shadow del volume, Copyright (C) 2005 Microsoft Corporation. "

Fondamentalmente, è un piccolo involucro pulito attorno a questi quattro comandi vshadow:

vshadow.exe -q - Elenca tutte le copie shadow nel sistema
vshadow.exe -p {elenco dei volumi} - Gestisce le copie shadow persistenti
vshadow.exe -el = {SnapID}, dir - Espone la copia shadow come punto di montaggio
vshadow.exe -ds = {SnapID} - Elimina questa copia shadow

Ecco la sua schermata di aiuto:

Strumento Crea / Monta istantanea VSS

Uso:
cscript / nologo VssSnapshot.vbs / target: percorso {/ volume: X | / unmount} [/ debug]

/ volume - lettera di unità del volume all'istantanea
/ target: il percorso (assoluto o relativo) su cui montare l'istantanea
/ debug - swich sull'output di debug

Esempi:
cscript / nologo VssSnapshot.vbs / target: C: \ Backup \ DriveD / volume: D
cscript / nologo VssSnapshot.vbs / target: C: \ Backup \ DriveD / unmount

Suggerimento: non è necessario smontare prima di scattare una nuova istantanea.

Ecco alcuni esempi di output:

C: \ VssSnapshot> cscript / nologo VssSnapshot.vbs / target: MountPoints \ E / volume: E
05/03/2010 17:13:04 preparazione del punto di montaggio VSS ...
05/03/2010 17:13:04 mount point preparato in: C: \ VssSnapshot \ MountPoints \ E
05/03/2010 17:13:04 creazione snapshot VSS per volume: E
05/03/2010 17:13:08 Istantanea creata con ID: {4ed3a907-c66f-4b20-bda0-9dcda3b667ec}
05/03/2010 17:13:08 Istantanea VSS montata correttamente
05/03/2010 17:13:08 terminato

C: \ VssSnapshot> cscript / nologo VssSnapshot.vbs / target: MountPoints \ E / unmount
05/03/2010 17:13:35 preparazione del punto di montaggio VSS ...
05/03/2010 17:13:36 nient'altro da fare
05/03/2010 17:13:36 finito

Ed ecco la sceneggiatura stessa. Si applica la solita dichiarazione di non responsabilità: il software viene fornito così com'è, non do alcuna garanzia, uso a proprio rischio, se qualcosa si rompe l'unico da incolpare è te stesso. L'ho provato abbastanza a fondo, però e funziona bene per me. Sentiti libero di avvisarmi di eventuali bug tramite i commenti qui sotto.

''# 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

Spero che questo aiuti qualcuno. Sentiti libero di usarlo secondo cc-by-sa . Tutto quello che ti chiedo è di lasciare intatto il link che punta qui.


E hai fatto un ripristino di emergenza completo dei dati da questo su un nuovo sistema? Effettuare un backup è facile. Ripristinando da esso a volte non tanto.
Rob Moir,

@Robert: questo vale sia per questo approccio che per qualsiasi altro tipo di backup. Seguirò non appena ciò avverrà attraverso la messa in scena.
Tomalak,

1
+1 per non aver accettato il no per una risposta e aver cercato di dimostrare che esiste una soluzione praticabile là fuori che alcuni degli altri poster avrebbero potuto offrire invece di rispondere che non può essere fatto.
Chris Magnuson,

Ciò ha fornito un backup ripristinabile? Potrebbe essere usato con Robocopy?
Kev

1
@Kev: Sì, ma dovresti assolutamente provarlo tu stesso. Se trovi un problema, per favore dimmelo qui. Puoi usare Robocopy o qualsiasi altro strumento che preferisci, il volume montato si comporta come un normale disco.
Tomalak,

6
  1. Utilizzare il comando vssadmin list shadowsper elencare tutte le copie shadow disponibili. Otterrai un output come questo ...
C: \> ombre elenco vssadmin
vssadmin 1.1 - Strumento da riga di comando amministrativo di Volume Shadow Copy Service
(C) Copyright 2001 Microsoft Corp.

Contenuto dell'ID set copia shadow: {b6f6fb45-bedd-4b77-8f51-14292ee921f3}
   Contiene 1 copie shadow al momento della creazione: 25/09/2016 12:14:23 PM
      ID copia shadow: {321930d4-0442-4cc6-b2aa-ec47f21d0eb1}
         Volume originale: (C:) \\? \ Volume {ad1dd231-1200-11de-b1df-806e6f6e6963} \
         Volume copia shadow: \\? \ GLOBALROOT \ Device \ HarddiskVolumeShadowCopy68
         Macchina originatrice: joshweb.josh.com
         Macchina di servizio: joshweb.josh.com
         Provider: "Provider di copie shadow software Microsoft 1.0"
         Tipo: ClientAccessible
         Attributi: persistente, accessibile al client, senza rilascio automatico, senza scrittori, differenziale

Contenuto dell'ID set copia shadow: {c4fd8646-57b3-4b39-be75-47dc8e7f881d}
   Contiene 1 copie shadow al momento della creazione: 25/8/2016 7:00:18
      ID copia shadow: {fa5da100-5d90-493c-89b1-5c27874a23c6}
         Volume originale: (E:) \\? \ Volume {4ec17949-12b6-11de-8872-00235428b661} \
         Volume copia shadow: \\? \ GLOBALROOT \ Device \ HarddiskVolumeShadowCopy3
         Macchina originatrice: joshweb.josh.com
         Macchina di servizio: joshweb.josh.com
         Provider: "Provider di copie shadow software Microsoft 1.0"
         Tipo: ClientAccessible
         Attributi: persistente, accessibile al client, senza rilascio automatico, senza scrittori, differenziale

C: \
  1. Nota il Shadow Copy Volumenome per la copia shadow che desideri (il più semplice per gli appunti).

  2. Montare la copia shadow

Su Windows 2003 ...

Dovrai scaricare gli strumenti del kit di risorse per il 2003 se non lo possiedi già.

Inserisci il comando ...

linkd c: \ shadow \\? \ GLOBALROOT \ Device \ HarddiskVolumeShadowCopy69 \

... dov'è c:\shadowil percorso in cui vuoi che appaia la copia shadow ed \\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy69è il nome che hai copiato sopra. Nota che devi aggiungere una barra rovesciata alla fine del nome della copia shadow!

Su Windows 2008 e versioni successive ...

Inserisci il comando ...

mklink c: \ shadow \\? \ GLOBALROOT \ Device \ HarddiskVolumeShadowCopy69 \

... dov'è c:\shadowil percorso in cui vuoi che appaia la copia shadow ed \\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy69è il nome che hai copiato sopra. Nota che devi aggiungere una barra rovesciata alla fine del nome della copia shadow!

  1. Usa qualsiasi strumento tu voglia (incluso Windows Explorer o XCOPY) per accedere ai file c:\shadow.

Quindi ... per automatizzare questo sarebbe necessario analizzare l'output da list shadows?
Kev,

Mi piace questa risposta, ma non ha funzionato abbastanza per me quando ho montato \\? \ GLOBALROOT \ Device \ HarddiskVolumeShadowCopy_n_ Invece ho usato il file di riferimento e il tempo di istantanea dalla condivisione root (C $ per esempio) mklink / DD: \ TempMount \\ localhost \ C $ \ @ GMT-2011.01.01-06.00.08 - sfortunatamente è probabile che si tratti di un processo manuale, ma per le emergenze funziona.
Lewis,

2

Stai fraintendendo come VSS funziona con il filesystem (come funziona con i database è completamente diverso). Nel file system, VSS viene utilizzato per implementare la funzione "Versioni precedenti", che viene utilizzata esclusivamente per lo snapshot delle modifiche a file e cartelle in punti predefiniti nel tempo per il ripristino tramite la scheda Versioni precedenti nei client. Queste modifiche vengono quindi unite ai dati sul volume per la creazione del set di ripristino. Quindi dipende dal fatto che il volume originale sia ancora presente per eseguire il ripristino, che è in altre parole inutile ai fini del backup e del ripristino corretti.

Penso che tu debba fare un passo indietro da come vuoi fare questo e ripensare a ciò che vuoi fare.

350 GB di dati non sono molti, e sono disposto a scommettere che la percentuale di ciò che viene attivamente utilizzata su base giornaliera è piuttosto bassa. Hai mai pensato di fare backup differenziali notturni con backup completi solo nei fine settimana? O utilizzando la replica DFS pianificata su un archivio alternativo per ottenere uno "snapshot" (di cui viene eseguito il backup)?


La quantità di modifiche è di circa 60 GB al giorno, in termini di backup differenziale. L'interruzione del servizio regolare è abbastanza lunga da infastidire gli utenti di tanto in tanto, forse "ore" è stato un po 'esagerato. Il mio punto è: quando eseguo il backup dell'istantanea VSS su nastro, ho tutto ciò di cui ho bisogno per ripristinare i dati con successo. Sto lavorando a una sceneggiatura che fa quello di cui ho bisogno attualmente, sembra abbastanza promettente. Lo posterò qui al termine.
Tomalak

@mh: ho pubblicato la mia sceneggiatura. È diventato un po 'più grande di quanto pensassi, ma funziona bene ed è comodo da usare. Dare un'occhiata! :)
Tomalak

1
-1 Hai frainteso la domanda. Non sta cercando di utilizzare VSS come origine di un backup, sta cercando di utilizzarlo per creare un'istantanea di sola lettura dei suoi file che può quindi trasferire su un'unità nastro o su un altro supporto. Non capisco perché questo non sia un grande caso d'uso per questa tecnologia?
Chris Magnuson,

2

Spero che questo sia quello che vuoi:

diskshadow -s vssbackup.cfg

vssbackup.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

diskshadow è Windows Server 2008, AFAIK.
Tomalak,

@jackbean: ho creato uno script che fa qualcosa di simile per Windows 2003, dato che finora non ho trovato nulla di convincente su Internet. Dai un'occhiata alla mia risposta.
Tomalak,

mi scuso, sono consapevole che è per il 2008, ma in qualche modo ce l'avevo in testa hai il 2008 R2.
jackbean

0

Utilizzando l'API VSS, è possibile eseguire uno "snapshot" del volume. Quindi dovresti montare quella istantanea per copiarla. Conosco un prodotto ormai morto che utilizzava questa tecnica per replicare i dati nonostante i file fossero aperti esclusivamente da altri processi nel file system live. Si possono sollevare domande valide sul fatto che i file nell'istantanea VSS siano coerenti se vengono scritti da app non integrate con le API VSS. Potrebbero esserci altri prodotti che offrono funzionalità simili.


@Fred: è quello che ho fatto, usando un VBScript e uno strumento da riga di comando di Microsoft. Vedi la mia risposta
Tomalak,

-1

Risposta breve: non puoi.

Risposta leggermente più lunga: il servizio di copia shadow può essere utilizzato in modo programmatico tramite la sua API per consentire il backup di file aperti ma il servizio non crea snapshot completi del sistema, solo snapshot parziali.


2
Mi rifiuto di credere che ciò sia impossibile. Non ho bisogno di una "istantanea del sistema" completa, ma solo una copia temporizzata di un singolo volume. Sono approssimativamente consapevole del funzionamento interno della copia shadow e sono consapevole che può essere utilizzato per eseguire il backup dei file in uso (esempi importanti in rete sono i database Exchange o SQL).
Tomalak

1
@John: si scopre che posso. Dai un'occhiata alla mia risposta!
Tomalak

Vedo che stai usando l'API più o meno come farebbe il software di backup. Quindi, mentre stai usando il servizio VSS è molto diverso dall'uso di Volume Shadow Copy. Tuttavia, se fa quello che vuoi, è tutto ciò che conta davvero. Molto bene.
John Gardeniers,

1
La tua risposta breve e lunga sono entrambe sbagliate e il termine "Volume Shadow Copy" dovrebbe essere stato sufficiente per indicare ciò che l'utente stava cercando anche se questo termine è leggermente ambiguo. en.wikipedia.org/wiki/Shadow_Copy
Chris Magnuson,

1
Forse hai ragione. Non capisco come la tua risposta "Non puoi" sia corretta quando l'OP ha trovato il modo di fare ciò che ha descritto. La tua lunga risposta non è pertinente alla domanda posta perché anche se l'API consente solo "istantanee parziali", puoi comunque montare una rappresentazione dell'intero volume in un determinato momento e eseguirne il backup come desiderato dall'OP. Se potessi chiarire cosa intendi nel tuo post originale in modo che venga modificato per indirizzare ciò che l'OP è stato in grado di realizzare, rimuoverò felicemente il voto negativo e aggiungerò un aggiornamento se le informazioni sono pertinenti.
Chris Magnuson,
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.