Como usar uma cópia de sombra de volume para fazer backups

11

O plano é criar uma cópia de sombra de um volume bastante grande de E / S. São 350 GB, contendo um índice de texto completo baseado em sistema de arquivos organizado em centenas de pastas e centenas de milhares de pequenos arquivos que precisam estar em um estado consistente para uma restauração bem-sucedida.

Atualmente, o indexador está parado, a tarefa de backup é executada e o indexador é reiniciado. Isso faz com que o índice fique indisponível por horas durante o backup. Eu gostaria de fazer backups consistentes via cópia de sombra, idealmente sem precisar parar o indexador.

Então, ativei o Shadow Copy para esse volume e o configurei para fazer um instantâneo uma vez por noite, para um volume diferente.

Agora estou um pouco perdido - como posso acessar a cópia de sombra como um todo, para poder fazer um backup? Eu imagino uma unidade somente leitura que contenha os arquivos como estavam no momento do último instantâneo, mas talvez as coisas funcionem completamente diferentes.

O sistema operacional é o Windows Server 2003 SP2, o software de backup é o CommVault Galaxy 7.0.


EDIT : Observe que, entretanto, foram criadas duas respostas que implementam a funcionalidade necessária na forma de um script:

Tomalak
fonte
A galáxia commvault já não usa o VSS para criar o backup? Lembro-me vagamente que CommVault foi um dos primeiros fornecedores para impleent uma solução de backup baseado VSS
Jim B
@ Jim: Sim, mas apenas para arquivos bloqueados em uma base de arquivo para arquivo. O que eu preciso é de todos os arquivos na unidade em um estado consistente. Mas isso não acontecerá, a menos que a) o indexador não seja executado ou b) eu tenha uma cópia de instantâneo, como as que o VSS pode fazer.
precisa
O VSS não funciona assim - é uma cópia de sombra VOLUME. Se ele usa o VSS, a única diferença é que, diferentemente do software de backup de snaps persistentes, ele usa snaps temporários. Suponho que um aplicativo possa tirar instantâneos de exclusão por arquivo, mas não apenas seus backups serão inconsistentes, como também o tempo para fazer backup de até uma instalação padrão do Windows será da ordem dos dias. Consulte msdn.microsoft.com/en-us/library/aa384589(VS.85).aspx para obter um diagrama de como o processamento do VSS funciona. Eu entraria em contato com o commvault e verificaria se eles podem garantir que sua configuração de backup esteja correta.
Jim B

Respostas:

10

Então, no espírito de reinventar a roda, apresento a você o excelente roteiro de Tomalak (veja acima), mas completamente reescrito em Powershell !!! A principal razão pela qual fiz isso foi evangelizar os incríveis poderes do PowerShell, mas também porque desprezo o vbscript com todo o meu ser.

É principalmente característica a característica idêntica, mas eu implementei algumas coisas de maneira um pouco diferente por várias razões. A saída de depuração é definitivamente mais detalhada.

Uma coisa muito importante a ser observada é que esta versão detecta a versão e o sistema operacional do SO e chama a versão apropriada do vshadow.exe. Eu incluí um gráfico abaixo para mostrar quais versões do vshadow.exe usar, onde obtê-las e como nomeá-las.


Aqui estão as informações de uso:

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

Aqui está o 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"

Aqui estão as versões vshadow.exe para usar:

  1. Windows 2003 / 2003R2
    • SDK 7.2 do Serviço de Cópia de Sombra de Volume
    • x86: C: \ Arquivos de programas \ Microsoft \ VSSSDK72 \ TestApps \ vshadow \ bin \ release-server \ vshadow.exe
      • Renomeie para: vshadow_2003_x86.exe
    • x64: Não consegui localizar uma versão x64 do vshadow.exe para Windows 2003 x64
  2. Windows 2008
    • Windows SDK para Windows Server 2008 e .NET Framework 3.5
    • x86: C: \ Arquivos de Programas \ Microsoft SDKs \ Windows \ v6.1 \ Bin \ vsstools \ vshadow.exe
      • Renomeie para: vshadow_2008_x86.exe
    • x64: C: \ Arquivos de programas \ Microsoft SDKs \ Windows \ v6.1 \ Bin \ x64 \ vsstools \ vshadow.exe
      • Renomeie para: vshadow_2008_x64.exe
  3. Windows 2008R2
    • Microsoft Windows SDK para Windows 7 e .NET Framework 4
    • x86: C: \ Arquivos de programas (x86) \ Microsoft SDKs \ Windows \ v7.0A \ Bin \ vsstools \ vshadow.exe
      • Renomeie para: vshadow_2008R2_x86.exe
    • x64: C: \ Arquivos de programas (x86) \ Microsoft SDKs \ Windows \ v7.0A \ Bin \ x64 \ vsstools \ vshadow.exe
      • Renomeie para: vshadow_2008R2_x64.exe
John Homer
fonte
2
btw ... Consegui implementar isso como parte de nossa solução de backup usando o Arcserve como um backup de arquivo aberto de pobre. É melhor do que pagar US $ 800 por servidor pela licença do agente. Se alguém estiver interessado, vou postar aqui.
John Homer
+1 Isso é incrível. Obrigado por reservar um tempo para portar isso para o ps (apesar do seu ódio pelo VBS) e por compartilhá-lo aqui. Espero que mais pessoas o considerem útil, pois isso definitivamente merece mais de uma votação.
precisa saber é o seguinte
9

Então ... eu tenho trabalhado em um pouco de VBScript que pode:

  • tire instantâneos persistentes do VSS
  • monte-os em uma pasta (da qual você poderá fazer backup dos arquivos)
  • desmontar snapshots do VSS

Ele se baseia em vshadow.exe( documentação ) parte do SDK 7.2 do Volume Shadow Copy Service, conforme disponível na Microsoft. Eu tenho trabalhado com esta versão: " VSHADOW.EXE 2.2 - Cliente de exemplo de cópia de sombra de volume, Copyright (C) 2005 Microsoft Corporation. "

Basicamente, é um pequeno invólucro interessante em torno desses quatro comandos vshadow:

vshadow.exe -q - lista todas as cópias de sombra no sistema
vshadow.exe -p {volume list} - gerencia cópias de sombra persistentes
vshadow.exe -el = {SnapID}, dir - expõe a cópia de sombra como um ponto de montagem
vshadow.exe -ds = {SnapID} - Exclui esta cópia de sombra

Aqui está sua tela de ajuda:

Ferramenta de criação / montagem de instantâneo do VSS

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

/ volume - letra da unidade do volume para a captura instantânea
/ target - o caminho (absoluto ou relativo) para montar o instantâneo no
/ debug - swich na saída de depuração

Exemplos:
cscript / nologo VssSnapshot.vbs / target: C: \ Backup \ DriveD / volume: D
cscript / nologo VssSnapshot.vbs / target: C: \ Backup \ DriveD / desmontar

Dica: Não é necessário desmontar antes de tirar uma nova captura instantânea.

Aqui estão alguns exemplos de saída:

C: \ VssSnapshot> cscript / nologo VssSnapshot.vbs / target: MountPoints \ E / volume: E
05/03/2010 17:13:04 preparando o ponto de montagem do VSS ...
05/03/2010 17:13:04 ponto de montagem preparado em: C: \ VssSnapshot \ MountPoints \ E
05/03/2010 17:13:04 criando um instantâneo do VSS para o volume: E
05/03/2010 17:13:08 instantâneo criado com o ID: {4ed3a907-c66f-4b20-bda0-9dcda3b667ec}
05/03/2010 17:13:08 Instantâneo do VSS montado com sucesso
05/03/2010 17:13:08 terminado

C: \ VssSnapshot> cscript / nologo VssSnapshot.vbs / target: MountPoints \ E / desmontar
05/03/2010 17:13:35 preparando o ponto de montagem do VSS ...
05/03/2010 17:13:36 nada mais a fazer
05/03/2010 17:13:36 finalizado

E aqui está o próprio script. O aviso de isenção usual se aplica: O software é fornecido como está, não dou garantias, use por seu próprio risco, se algo quebrar o único culpado é você mesmo. Eu o testei completamente, e funciona bem para mim. Sinta-se livre para me notificar sobre quaisquer erros através dos comentários abaixo.

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

Espero que isso ajude alguém. Sinta-se livre para usá-lo de acordo com cc-by-sa . Tudo o que peço é que você deixe intacto o link que aponta aqui.

Tomalak
fonte
E você fez uma recuperação completa de desastres dos dados disso em um novo sistema? Fazer um backup é fácil. Restaurar dele às vezes nem tanto.
quer
@ Robert: Isso é verdade tanto para essa abordagem quanto para qualquer outro tipo de backup. Vou acompanhar assim que isso terminar.
precisa
1
+1 por não aceitar não como resposta e pressionar para provar que existe uma solução viável por aí que alguns dos outros pôsteres poderiam oferecer, em vez de responder que isso não pode ser feito.
Chris Magnuson
Isso acabou fornecendo um backup restaurável? Poderia ser usado com o Robocopy?
Kev
1
@ Kev: Sim, mas você definitivamente deveria testá-lo. Se você encontrar algum problema, por favor me diga aqui. Você pode usar o Robocopy ou qualquer outra ferramenta de sua preferência, o volume montado se comporta como uma unidade normal.
precisa
6
  1. Use o comando vssadmin list shadowspara listar todas as cópias de sombra disponíveis. Você obterá uma saída como esta ...
C: \> sombras da lista vssadmin
vssadmin 1.1 - Ferramenta de linha de comando administrativa do Volume Shadow Copy Service
(C) Direitos autorais 2001 Microsoft Corp.

Conteúdo do ID do conjunto de cópias de sombra: {b6f6fb45-bedd-4b77-8f51-14292ee921f3}
   Continha 1 cópia de sombra no momento da criação: 25/09/2016 12:14:23
      ID de cópia de sombra: {321930d4-0442-4cc6-b2aa-ec47f21d0eb1}
         Volume original: (C:) \\? \ Volume {ad1dd231-1200-11de-b1df-806e6f6e6963} \
         Volume de cópias de sombra: \\? \ GLOBALROOT \ Device \ HarddiskVolumeShadowCopy68
         Máquina de origem: joshweb.josh.com
         Máquina de serviço: joshweb.josh.com
         Fornecedor: 'Microsoft Software Shadow Copy provider 1.0'
         Tipo: ClientAccessible
         Atributos: Persistente, Acessível ao Cliente, Sem Liberação Automática, Sem Gravadores, Diferencial

Conteúdo do ID do conjunto de cópias de sombra: {c4fd8646-57b3-4b39-be75-47dc8e7f881d}
   Continha 1 cópia de sombra no momento da criação: 25/8/2016 7:00:18
      ID de cópia de sombra: {fa5da100-5d90-493c-89b1-5c27874a23c6}
         Volume original: (E:) \\? \ Volume {4ec17949-12b6-11de-8872-00235428b661} \
         Volume de cópias de sombra: \\? \ GLOBALROOT \ Device \ HarddiskVolumeShadowCopy3
         Máquina de origem: joshweb.josh.com
         Máquina de serviço: joshweb.josh.com
         Fornecedor: 'Microsoft Software Shadow Copy provider 1.0'
         Tipo: ClientAccessible
         Atributos: Persistente, Acessível ao Cliente, Sem Liberação Automática, Sem Gravadores, Diferencial

C: \
  1. Anote o Shadow Copy Volumenome da cópia de sombra desejada (mais fácil para a área de transferência).

  2. Montar a cópia de sombra

No Windows 2003 ...

Você precisará fazer o download das ferramentas do kit de recursos para 2003, se ainda não o tiver.

Digite o comando ...

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

... onde c:\shadowé o caminho em que você deseja que a cópia de sombra apareça e \\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy69é o nome que você copiou acima. Observe que você deve adicionar uma barra invertida no final do nome da cópia de sombra!

No Windows 2008 e versões posteriores ...

Digite o comando ...

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

... onde c:\shadowé o caminho em que você deseja que a cópia de sombra apareça e \\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy69é o nome que você copiou acima. Observe que você deve adicionar uma barra invertida no final do nome da cópia de sombra!

  1. Use qualquer ferramenta que você desejar (incluindo o Windows Explorer ou XCOPY) para acessar os arquivos c:\shadow.
Tero Kilkanen
fonte
Então ... para automatizar isso, você precisaria analisar a saída list shadows?
Kev
Eu gosto dessa resposta, mas ela não funcionou muito para mim ao montar o \\? \ GLOBALROOT \ Device \ HarddiskVolumeShadowCopy_n_ Em vez disso, usei o arquivo referenciado e o tempo da captura instantânea do compartilhamento raiz (C $ por exemplo) mklink / DD: \ TempMount \\ localhost \ C $ \ @ GMT-2011.01.01-06.00.08 - infelizmente, é provável que seja um processo manual, mas, para emergências, funciona.
Lewis
2

Você está entendendo mal como o VSS funciona com o sistema de arquivos (como ele funciona com bancos de dados é completamente diferente). No sistema de arquivos, o VSS é usado para implementar o recurso "Versões Anteriores", que é usado apenas para capturar instantaneamente alterações em arquivos e pastas em momentos predefinidos no tempo para recuperação por meio da guia Versões Anteriores nos clientes. Essas alterações são mescladas com os dados no volume para criar o conjunto de recuperação. Portanto, depende do volume original ainda estar presente para executar a recuperação, ou seja, inútil para fins de backup e restauração adequados.

Acho que você precisa se afastar de como deseja fazer isso e pensar novamente sobre o que quer fazer.

Na verdade, 350 GB de dados não são muitos, e estou disposto a apostar que a porcentagem que é usada ativamente no dia a dia é bastante baixa. Você já pensou em fazer backups diferenciais noturnos com backups completos apenas nos finais de semana? Ou usando a replicação agendada do DFS para armazenamento alternativo para obter um "instantâneo" (que é então copiado)?

Maximus Minimus
fonte
A quantidade de alterações é de cerca de 60 GB por dia, em termos de um backup diferencial. A interrupção regular do serviço é longa o suficiente para incomodar os usuários ocasionalmente, talvez "horas" tenha sido um pouco exagerada. O que quero dizer é: quando eu faço backup do instantâneo do VSS em fita, tenho tudo o que preciso para restaurar os dados com êxito. Estou trabalhando em um script que faz o que eu preciso atualmente, parece bastante promissor. Vou publicá-lo aqui quando terminar.
precisa
@mh: Eu postei meu script. Tornou-se um pouco maior do que eu pretendia, mas funciona bem e é conveniente de usar. Dar uma olhada! :)
Tomalak
1
-1 Você interpretou mal a pergunta. Ele não está tentando usar o VSS como a fonte de um backup, ele está tentando usá-lo para criar um instantâneo de tempo de leitura dos arquivos que pode ser transferido para uma unidade de fita ou outro meio. Não entendo por que esse não é um ótimo caso de uso para essa tecnologia?
Chris Magnuson
2

Espero que isto seja o que você deseja:

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
feijão
fonte
diskshadow é o Windows Server 2008, AFAIK.
precisa
@jackbean: Eu criei um script que faz algo semelhante ao Windows 2003, pois não encontrei nada convincente na Internet até agora. Dê uma olhada na minha resposta.
precisa
minhas desculpas, eu sei que é para 2008, mas de alguma forma eu tinha isso em mente que você tem 2008 R2.
feijão-sabre
0

Usando a API do VSS, é possível tirar um "instantâneo" do volume. Então você teria que montar esse instantâneo para copiar dele. Estou familiarizado com um produto agora morto que usou essa técnica para replicar dados, apesar de os arquivos serem abertos exclusivamente por outros processos no sistema de arquivos ao vivo. Perguntas válidas podem ser levantadas sobre se os arquivos no instantâneo do VSS são autoconsistentes se estiverem sendo gravados por aplicativos que não estão integrados às APIs do VSS. Pode haver outros produtos que oferecem recursos semelhantes.

Fred
fonte
@ Fred: Foi o que eu fiz, usando um VBScript e uma ferramenta de linha de comando da Microsoft. Veja minha resposta.
precisa
-1

Resposta curta: você não pode.

Resposta um pouco mais longa: o serviço de cópia de sombra pode ser usado de maneira programática por meio de sua API para permitir o backup de arquivos abertos, mas o serviço não cria instantâneos completos do sistema, apenas instantâneos parciais.

John Gardeniers
fonte
2
Eu me recuso a acreditar que isso é impossível. Não preciso do "instantâneo do sistema" completo, apenas uma cópia pontual de um único volume. Estou ciente de como a cópia de sombra funciona internamente e sei que ela pode ser usada para fazer backup de arquivos em uso (exemplos de destaque na rede são bancos de dados Exchange ou SQL).
quer
1
@ John: Acontece que eu posso. Dê uma olhada na minha resposta!
precisa
Vejo que você está usando a API da mesma forma que o software de backup usaria. Portanto, enquanto você usa o serviço VSS, é bem diferente usar o Volume Shadow Copy. No entanto, se ele faz o que você quer, é tudo o que realmente importa. Bem feito.
John Gardeniers
1
Sua resposta curta e longa está errada e o termo "Cópia de sombra de volume" deveria ter sido suficiente para indicar o que o usuário estava procurando, mesmo que esse termo seja um pouco ambíguo. en.wikipedia.org/wiki/Shadow_Copy
Chris Magnuson
1
Talvez você esteja certo. Não entendo como sua resposta "Você não pode" está correta quando o OP encontrou uma maneira de fazer o que ele descreveu. Sua resposta longa não é relevante para a pergunta, pois, embora a API permita apenas "snapshots parciais", você ainda pode montar uma representação de todo o volume em um determinado momento e fazer o backup conforme o OP desejado. Se você puder esclarecer o que você quer dizer em sua postagem original, para que ela seja editada para abordar o que o OP conseguiu realizar, removerei com satisfação o voto negativo e adicionarei um aumento se as informações forem relevantes.
Chris Magnuson