Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

Fazer backup do SQL Server usando snapshots instantâneos

Se os arquivos de banco de dados do SQL Server estiverem distribuídos em vários discos, você poderá 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 do Instant Snapshot 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 oferece suporte a implantações do Windows e do Linux e minimiza o impacto de performance nas 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 para o SQL Server para suspender todas as operações de gravação nos bancos de dados de destino. Isso garante que os arquivos de 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 de discos em que os dados e os arquivos de registro do banco de dados residem. Isso equivale a usar um mecanismo de snapshot de hardware ou de serviço. Google Cloud
Gravar e descongelar: o script envia outro comando T-SQL para o 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 Instant Snapshots e é gravado no msdb histórico de backup. Após a conclusão, o SQL Server descongela automaticamente o banco de dados e retoma as operações normais.

Todo esse processo é 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 concluir as seguintes tarefas:

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

Custos

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

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

Novos Google Cloud usuários 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 ou selecionar um projeto atual:
1. No Google Cloud console do, na página do seletor de projetos, selecione ou crie um Google Cloud projeto do.
  Papéis necessários para selecionar ou criar um projeto
  - Selecionar um projeto: a seleção de um projeto não exige um papel específico do IAM. É possível selecionar qualquer projeto em que você tenha recebido um papel.
  - Criar um projeto: para criar um projeto, você precisa do papel de criador de projetos (roles/resourcemanager.projectCreator), que contém a resourcemanager.projects.create permissão. Saiba como conceder papéis.
  Observação: se você não planeja manter os recursos criados neste procedimento, crie um projeto em vez de selecionar um projeto atual. 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 Google Cloud projeto.
3. No Google Cloud console do, ative o Cloud Shell.
  
  Ativar o Cloud Shell
Verifique se o Microsoft SQL Server 2022 ou versões mais recentes estão instalados 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 permissão ALTER DATABASE para o banco de dados de destino.

Para receber as permissões necessárias para 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 personalizados papéis ou outros predefinidos papéis.

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 Google Cloud console
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 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 script do PowerShell a seguir 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 Arquivo, selecione Arquivo > Novo > Consulta com a conexão atual.

Copie o código a seguir para a 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 o script de snapshot

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

Usando a mesma sessão de Á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 executando 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 Google Cloud console.

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