O Google usa tecnologia de IA na tradução de conteúdos para seu idioma de preferência. As traduções com IA podem ter erros.

Fazer backup do SQL Server usando snapshots instantâneos

Se os arquivos do banco de dados do SQL Server estiverem distribuídos em vários discos, será possível fazer backup de todos os discos simultaneamente, mantendo a consistência do aplicativo e dos dados. Você consegue esse backup pontual exato com grupos de consistência de snapshots instantâneos do Compute Engine, que permitem fazer backup de dados em um grupo de discos.

Este tutorial descreve como fazer backup de bancos de dados do SQL Server com snapshots do Compute Engine e o recurso de snapshot do Transact-SQL (T-SQL) disponível no SQL Server 2022 e versões mais recentes. Essa solução é compatível com implantações do Windows e do Linux e minimiza o impacto no desempenho das cargas de trabalho ativas.

Como funciona

O fluxo de trabalho consiste nestas etapas principais, que são gerenciadas por um script em execução em uma instância de computação:

Congelar o banco de dados: o script envia um comando T-SQL ao SQL Server para suspender todas as operações de gravação nos bancos de dados de destino. Isso garante que os arquivos do banco de dados estejam em um estado consistente para o backup.
Criar instant snapshots: enquanto o banco de dados está congelado, crie um grupo de instant snapshots dos discos em que os arquivos de dados e de registro do banco de dados estão localizados. Esse é o equivalente Google Cloud ao uso de um mecanismo de snapshot de hardware ou de nível de serviço.
Gravar e descongelar: o script envia outro comando T-SQL ao SQL Server para gravar os metadados de backup. Esse comando cria um pequeno arquivo de backup que aponta para o grupo de consistência de snapshots instantâneos e é registrado no histórico de backup msdb. Após a conclusão, o SQL Server descongelará automaticamente o banco de dados e retomará as operações normais.

Todo esse processo normalmente é concluído em menos de um segundo, minimizando a duração do congelamento de gravação no banco de dados. Enquanto o congelamento estiver em vigor, os dados poderão ser lidos, mas não gravados. É possível cancelar manualmente o estado de congelamento definindo SUSPEND_FOR_SNAPSHOT_BACKUP=OFF para o banco de dados.

Objetivos

Neste tutorial, você vai aprender a:

Crie uma instância do SQL Server com dois discos de dados.
Crie um novo banco de dados com os arquivos de dados e de registros em discos separados.
Crie um grupo de consistência de todos os discos da VM que executa o SQL Server.
Crie Instant Snapshots do grupo de discos.
Crie novos discos com base nos instant snapshots.

Custos

Neste documento, você usará os seguintes componentes faturáveis do Google Cloud:

Para gerar uma estimativa de custo baseada na sua projeção de uso, use a calculadora de preços.

Novos usuários do Google Cloud podem estar qualificados para um teste sem custo financeiro.

Ao concluir as tarefas descritas neste documento, é possível evitar o faturamento contínuo excluindo os recursos criados. Para mais informações, consulte Limpeza.

Antes de começar

Para este tutorial, você precisa de um Google Cloud projeto. É possível criar um novo projeto ou selecionar um que já foi criado:
1. No console do Google Cloud , na página do seletor de projetos, selecione ou crie um projeto do Google Cloud .
  Papéis necessários para selecionar ou criar um projeto
  - Selecionar um projeto: não é necessário um papel específico do IAM para selecionar um projeto. Você pode escolher qualquer projeto em que tenha recebido um papel.
  - Criar um projeto: para criar um projeto, é necessário ter o papel de Criador de projetos (roles/resourcemanager.projectCreator), que contém a permissão resourcemanager.projects.create. Saiba como conceder papéis.
  Observação: se você não pretende manter os recursos criados neste procedimento, crie um projeto em vez de selecionar um que já existe. Depois de concluir essas etapas, é possível excluir o projeto. Para fazer isso, basta remover todos os recursos associados a ele.
  
  Acessar o seletor de projetos
2. Verifique se o faturamento está ativado para o projeto do Google Cloud .
3. No console do Google Cloud , ative o Cloud Shell.
  
  Ativar o Cloud Shell
Verifique se o Microsoft SQL Server 2022 ou uma versão mais recente está instalado e em execução.

Permissões necessárias

Além do acesso de leitura padrão, verifique se o administrador do SQL Server concedeu a você a permissão ALTER DATABASE para o banco de dados de destino.

Para receber as permissões necessárias e criar instâncias e snapshots, peça ao administrador para conceder a você os seguintes papéis do IAM no projeto:

Gerenciar instância: compute.instanceAdmin.v1
Criar snapshots: compute.storageAdmin

Para mais informações sobre a concessão de papéis, consulte Gerenciar o acesso a projetos, pastas e organizações.

Também é possível conseguir as permissões necessárias usando papéis personalizados ou outros papéis predefinidos.

Criar uma instância do SQL do Compute Engine

Crie uma instância do SQL Server.

No console do Google Cloud , abra o Cloud Shell clicando no botão Ativar o Cloud Shell .

Acesse o console do Google Cloud .
Crie uma instância do SQL Server. Cole o seguinte comando:

  REGION=REGION
  ZONE=$REGION-a
  VM_NAME=VM_NAME
  gcloud compute instances create $VM_NAME \
    --boot-disk-auto-delete \
    --boot-disk-size 100 \
    --boot-disk-type hyperdisk-balanced \
    --image-family sql-std-2022-win-2025 \
    --image-project windows-sql-cloud \
    --machine-type c4-highmem-4 \
    --zone $ZONE \
    --network-interface subnet=default \
    --tags sql-server-instant-snapshot \
    --scopes=cloud-platform,service-control,service-management,monitoring-write,logging-write,storage-rw \
    --create-disk=device-name=$VM_NAME-data-disk1,mode=rw,name=$VM_NAME-data-disk1,size=100,type=hyperdisk-balanced \
    --create-disk=device-name=$VM_NAME-data-disk2,mode=rw,name=$VM_NAME-data-disk2,size=100,type=hyperdisk-balanced

Substitua:

Região: a região em que a nova instância será implantada.
VM_NAME: o nome da sua nova instância do SQL Server.

Criar um grupo de consistência de discos

Crie um grupo de consistência.

gcloud compute resource-policies create disk-consistency-group $VM_NAME-snap-grp \
    --region=$REGION

Adicione os discos da VM ao grupo de consistência.

gcloud compute disks add-resource-policies $VM_NAME \
    --zone=$ZONE \
    --resource-policies=$VM_NAME-snap-grp

gcloud compute disks add-resource-policies $VM_NAME-data-disk1 \
    --zone=$ZONE \
    --resource-policies=$VM_NAME-snap-grp

gcloud compute disks add-resource-policies $VM_NAME-data-disk2 \
    --zone=$ZONE \
    --resource-policies=$VM_NAME-snap-grp

criar um banco de dados;

Crie um nome de usuário e uma senha para a instância de VM.
Conecte-se à VM usando a Área de trabalho remota e faça login usando o nome de usuário e a senha criados na etapa anterior.
Clique com o botão direito do mouse no botão Iniciar (ou pressione Win+X) e clique em Terminal (administrador).
Confirme a elevação do prompt clicando em Sim.

Execute o seguinte script do PowerShell na janela do terminal aberta. Esse script inicializa o disco de dados, formata o disco com um tamanho de bloco de 64 KB e atribui uma letra de unidade.

$availableDisks = Get-PhysicalDisk -CanPool $True
$diskLetters = [char[]] (68..72) | Where-Object { !(Get-PSDrive $_ -ErrorAction SilentlyContinue) }
$diskCount = 0
foreach ($disk in $availableDisks) {
    $diskLetter = $diskLetters[$diskCount]
    $diskLabel = "$diskLetter-DataDisk"
    Initialize-Disk -Number $disk.DeviceId -PartitionStyle MBR -PassThru

    New-Partition -DiskNumber $disk.DeviceId -UseMaximumSize `
    -DriveLetter $diskLetter | Format-Volume -FileSystem NTFS `
    -NewFileSystemLabel $diskLabel -AllocationUnitSize 65536 -Confirm:$false

    New-Item -ItemType Directory -Path "$($diskLetter):\MSSQL"
    $diskCount = $diskCount +1
}

Abra o SQL Server Management Studio (SSMS). Execute-o como administrador.
Na caixa de diálogo "Conectar-se ao servidor", verifique se o nome do servidor está definido como localhost e selecione Conectar.
No menu de arquivos, selecione Arquivo > Novo > Consulta com a conexão atual.

Copie o código a seguir na janela de consulta recém-aberta.

USE Master;
GO
CREATE DATABASE SnapBackupDB
ON PRIMARY
(
    NAME = 'SnapBackupDB_Data',
    FILENAME = 'D:\MSSQL\SnapBackupDB.mdf',
    SIZE = 500MB,
    MAXSIZE = UNLIMITED,
    FILEGROWTH = 64MB
)
LOG ON
(
    NAME = 'SnapBackupDB_Log',
    FILENAME = 'E:\MSSQL\SnapBackupDB_log.ldf',
    SIZE = 250MB,
    MAXSIZE = 2GB,
    FILEGROWTH = 64MB
);

Implantar script de snapshot

Esse script automatiza todo o processo necessário para criar snapshots consistentes de aplicativos dos discos anexados à VM que executa o SQL Server.

Na mesma sessão da Área de Trabalho Remota, abra o Bloco de Notas.
Copie o conteúdo do script a seguir e cole na janela do bloco de notas aberta.

Salve o arquivo como take-snapshot.ps1 em c:\scripts.

# Import Modules
Import-Module -Name SQLPS

# Set variables
$formattedTimestamp = Get-Date -Format 'yyyyMMdd-HHmmss'
$backupLocation = 'D:\MSSQL\Backup'
$dbName = 'SnapBackupDB'
$bkmFile = Join-Path -Path $backupLocation  -ChildPath ("${dbName}_${formattedTimestamp}.bkm")
$sqlServer = 'localhost'

# SQL Commands
$suspendDbCmd = "ALTER DATABASE [$dbName] SET SUSPEND_FOR_SNAPSHOT_BACKUP=ON WITH NO_WAIT;"
$backupMetadataCmd = "BACKUP DATABASE [$dbName] TO DISK='$bkmFile' WITH METADATA_ONLY, FORMAT;"
$unsuspendDbCmd = "ALTER DATABASE [$dbName] SET SUSPEND_FOR_SNAPSHOT_BACKUP=OFF;"

# --- Helper Function for SQL Execution ---
function Invoke-MySqlCommand {
    param(
        [Parameter(Mandatory=$true)]
        [string]$CommandText,
        [Parameter(Mandatory=$true)]
        [System.Data.SqlClient.SqlConnection]$SqlConnection
    )
    Write-Host "Executing SQL Command: $($CommandText)"
    try {
        $Command = New-Object System.Data.SqlClient.SqlCommand($CommandText, $SqlConnection)
        $Result = $Command.ExecuteNonQuery()
        return $true
    }
    catch {
        Write-Host "Error executing SQL Command: $($CommandText)`n$($_.Exception.Message)" -ForegroundColor Red
        return $false
    }
}

$sqlConn = New-Object System.Data.SqlClient.SqlConnection
$sqlConn.ConnectionString = "server='$sqlServer';database='$dbName';Integrated Security=True;"
$databaseSuspended = $false

if (-not(Test-Path $backupLocation)) {
    New-Item -Path $backupLocation -ItemType directory -Force
}

try {
    $instanceName = (Invoke-RestMethod -Headers @{"Metadata-Flavor"="Google"} -Uri "http://metadata.google.internal/computeMetadata/v1/instance/name")
    $vmConfigString = (gcloud compute instances list --filter="name=('$instanceName')" --format=json --quiet)
    if ($LASTEXITCODE -ne 0) {
        Write-Host "Error querying gcloud for VM instances (exit code: $LASTEXITCODE). Exiting." -ForegroundColor Red
        exit 1
    }
    $vmConfig = $vmConfigString | ConvertFrom-Json

    # Open SQL Server connection
    $sqlConn.Open()

    # Suspend Database
    Write-Host "Suspending database '$dbName' for snapshot..."
    if (-not (Invoke-MySqlCommand -CommandText $suspendDbCmd -SqlConnection $sqlConn)) {
        Write-Host "Failed to suspend database. Exiting." -ForegroundColor Red
        exit 1
    }
    $databaseSuspended = $true

    # Take a disk snapshot
    try {
        $consistencyGroupListStr = (gcloud compute resource-policies list --filter='name:*-snap-grp' --format=json --quiet)
        if ($LASTEXITCODE -ne 0) { throw "gcloud resource-policies list failed (exit code: $LASTEXITCODE)." }
        $consistencyGroupList = $consistencyGroupListStr | ConvertFrom-Json

        if (@($consistencyGroupList).Count -eq 0) { throw "No consistency group found matching '*-snap-grp'." }
        if (@($consistencyGroupList).Count -gt 1) { Write-Warning "More than one consistency group found, using the first one." }

        $consistencyGroupSelfLink = $consistencyGroupList[0].selfLink
        $zoneName = Split-Path $vmConfig[0].zone -Leaf
        $snapshotName = "$($vmConfig.Name)-${formattedTimestamp}"

        $snapshotCmd = "gcloud compute instant-snapshot-groups create $snapshotName --source-consistency-group=$consistencyGroupSelfLink --zone=$zoneName --quiet"
        Invoke-Expression $snapshotCmd
        if ($LASTEXITCODE -ne 0) { throw "gcloud compute instant-snapshot-groups create failed (exit code: $LASTEXITCODE)." }
        Write-Host "Instant snapshot group created successfully."
    }
    catch {
        Write-Host "Error during snapshot creation: $($_.Exception.Message)" -ForegroundColor Red
        exit 1 # Exit after handling in finally
    }

    # Backup database metadata
    if (-not (Invoke-MySqlCommand -CommandText $backupMetadataCmd -SqlConnection $sqlConn)) {
        Write-Host "Failed to backup database metadata." -ForegroundColor Red
        exit 1
    }

    # Unsuspend Database
    Write-Host "Unsuspending database '$dbName'..."
    if (-not (Invoke-MySqlCommand -CommandText $unsuspendDbCmd -SqlConnection $sqlConn)) {
        Write-Host "Failed to unsuspend database after successful snapshot and metadata backup. Manual intervention may be required." -ForegroundColor Red
        exit 1
    }
    $databaseSuspended = $false # Successfully unsuspended

}
catch {
    Write-Host "An unhandled error occurred: $($_.Exception.Message)" -ForegroundColor Red
    exit 1
}
finally {
    if ($databaseSuspended -and ($sqlConn.State -eq [System.Data.ConnectionState]::Open)) {
        if (-not (Invoke-MySqlCommand -CommandText $unsuspendDbCmd -SqlConnection $sqlConn)) {
            Write-Host "Failed to unsuspend database in finally block. Manual intervention may be required." -ForegroundColor Red
        }
    }

    # Ensure SQL connection is closed
    if ($sqlConn.State -eq [System.Data.ConnectionState]::Open) {
        $sqlConn.Close()
    }
}

Clique com o botão direito do mouse no botão Iniciar (ou pressione Win+X) e clique em Terminal (administrador).
Confirme a elevação do prompt clicando em Sim.
Execute o script com o comando a seguir.
```
    C:\scripts\take-snapshot.ps1
```

Verificar se os Instant Snapshots foram criados

Execute os comandos a seguir no Cloud Shell:

Verifique se o script criou os snapshots.

    gcloud compute instant-snapshots list --filter="name:$VM_NAME*"

Liste os grupos de Instant Snapshot.

    gcloud compute instant-snapshot-groups list --zones $ZONE

Confira os detalhes do grupo de Instant Snapshot.

    gcloud compute instant-snapshot-groups describe  \
    INSTANT_SNAPSHOT_NAME --zone=$ZONE

Copie o valor selfLink para usar na próxima seção.

Restaurar os Instant Snapshots para novos discos

Execute os comandos a seguir na janela do console Google Cloud .

Crie discos com base no grupo de consistência de instant snapshots.

    gcloud compute disks bulk create --source-instant-snapshot-group \
    INSTANT_SNAPSHOT_NAME_URL \
    --source-instant-snapshot-group-region $REGION --zone=$ZONE

Confirme se os snapshots foram restaurados listando os discos na zona.

    gcloud compute disks list --zones=$ZONE --filter="name:$VM_NAME-*"

Crie uma nova VM com base nos discos recém-criados.

REGION=REGION
ZONE=$REGION-a
VM_NAME=VM_NAME
gcloud compute instances create $VM_NAME \
    --machine-type c4-highmem-4 \
    --zone $ZONE \
    --network-interface subnet=default \
    --tags sql-server-instant-snapshot \
    --disk=name=BOOT_DISK_NAME,boot=yes,auto-delete=no \
    --disk=name=DATA_DISK_1_NAME,mode=rw,auto-delete=no \
    --disk=name=DATA_DISK_2_NAME,mode=rw,auto-delete=no