Backup do SQL Server para URL

Este tópico apresenta os conceitos, os requisitos e os componentes necessários para usar o serviço de Armazenamento de Blobs do Azure como destino de backup. A funcionalidade de backup e restauração tem o mesmo efeito de DISK ou TAPE, com algumas diferenças. As diferenças, todas as exceções notáveis e alguns exemplos de código são incluídos neste tópico.

Requisitos, componentes e conceitos

Nesta seção:

• Segurança

• Introdução aos principais componentes e conceitos

• Serviço Armazenamento de Blobs do Azure

• Componentes do SQL Server

• Limitações

• Suporte para instruções de backup/restauração

• Usando a tarefa de backup no SQL Server Management Studio

• Backup do SQL Server para a URL usando o Assistente de Plano de Manutenção

• Restaurar a partir do armazenamento do Azure por meio do SQL Server Management Studio

Segurança

Veja a seguir considerações e requisitos de segurança ao fazer backup ou restauração dos serviços de Armazenamento de Blobs do Azure.

• Ao criar um contêiner para o serviço de Armazenamento de Blobs do Azure, recomendamos que você defina o acesso como privado. A definição do acesso como privado restringe o acesso a usuários ou contas capazes de fornecer as informações necessárias para realizar a autenticação na conta do Azure.

  Importante

  SQL Server requer que o nome da conta do Azure e a autenticação de chave de acesso sejam armazenados em uma credencial de SQL Server. Essas informações são usadas para autenticar na conta do Azure quando ela executa operações de backup ou restauração.

• A conta de usuário usada para emitir os comandos BACKUP ou RESTORE deve estar na função de banco de dados operador db_backup com as permissões Alterar qualquer credencial .

Introdução aos principais componentes e conceitos

As duas seções a seguir apresentam o serviço de Armazenamento de Blobs do Azure e os componentes SQL Server usados ao fazer backup ou restaurar do serviço de Armazenamento de Blobs do Azure. É importante entender os componentes e a interação entre eles para fazer um backup ou restaurar do serviço de Armazenamento de Blobs do Azure.

Criar uma conta do Azure é a primeira etapa desse processo. SQL Server usa o nome da conta de armazenamento do Azure e seus valores de chave de acesso para autenticar e gravar e ler blobs no serviço de armazenamento. A credencial do SQL Server armazena essas informações de autenticação e as utiliza durante as operações de backup ou restauração. Para obter um passo a passo completo sobre como criar uma conta de armazenamento e executar uma restauração simples, consulte Tutorial usando o Serviço de Armazenamento do Azure para SQL Server Backup e Restauração.

Serviço Armazenamento de Blobs do Azure

Conta de armazenamento: A conta de armazenamento é o ponto de partida de todos os serviços de armazenamento. Para acessar o serviço Armazenamento de Blobs do Azure, primeiro crie uma conta de armazenamento do Azure. O nome da conta de armazenamento e suas propriedades de chave de acesso são necessários para autenticar o serviço Armazenamento de Blobs do Azure e seus componentes.

Recipiente: Um contêiner fornece um agrupamento de um conjunto de Blobs e pode armazenar um número ilimitado de Blobs. Para gravar um backup SQL Server no serviço Blob do Azure, você deve ter pelo menos o contêiner raiz criado.

Blob: Um arquivo de qualquer tipo e tamanho. Há dois tipos de blobs que podem ser armazenados no serviço de Armazenamento de Blobs do Azure: blobs de blocos e páginas. SQL Server backup usa blobs de página como o tipo de Blob. Os blobs são endereçáveis usando o seguinte formato de URL: https://< storage account.blob.core.windows.net/>< container>/<blob>

Para obter mais informações sobre o serviço de Armazenamento de Blobs do Azure, consulte Como usar o serviço Armazenamento de Blobs do Azure

Para obter mais informações sobre blobs de páginas, consulte Noções gerais sobre blobs de blocos e blobs de páginas

Componentes do SQL Server

URL: Uma URL especifica um URI (Uniform Resource Identifier) para um arquivo de backup exclusivo. A URL é usada para fornecer o local e o nome do arquivo de backup do SQL Server . Nessa implementação, a única URL válida é aquela que aponta para um Blob de páginas em uma conta de armazenamento do Azure. A URL deve apontar para um Blob real, e não apenas para um contêiner. Se o Blob não existir, ele será criado. Se um Blob existente for especificado, BACKUP falhará, a menos que a opção "WITH FORMAT" seja especificada.

Aqui está um valor de URL de exemplo: http[s]://ACCOUNTNAME.Blob.core.windows.net/< CONTAINER>/<FILENAME.bak>. O HTTPS não é obrigatório, mas é recomendado.

Credencial: Uma credencial do SQL Server é um objeto usado para armazenar as informações de autenticação necessárias para se conectar a um recurso fora do SQL Server. Aqui, SQL Server processos de backup e restauração usam credenciais para autenticar no serviço de Armazenamento de Blobs do Azure. A Credencial armazena o nome da conta de armazenamento e os valores de access key da conta de armazenamento. Depois que a credencial for criada, ela deverá ser especificada na opção WITH CREDENTIAL ao emitir instruções BACKUP/RESTORE. Para obter mais informações sobre como exibir, copiar ou gerar novamente as access keysda conta de armazenamento, consulte Chaves de acesso da conta de armazenamento.

Para obter instruções passo a passo sobre como criar uma credencial SQL Server, consulte Criar um exemplo de credencial mais adiante neste tópico.

Para obter informações gerais sobre credenciais, consulte Credenciais

Para obter informações, em outros exemplos em que as credenciais são usadas, consulte Criar um proxy de SQL Server Agent.

Limitações

• Não há suporte para backup em armazenamento premium.

• O tamanho máximo de backup com suporte é 1 TB.

• Você pode emitir instruções de backup ou restauração usando cmdlets do TSQL, SMO ou PowerShell. Um backup ou restauração do serviço de Armazenamento de Blobs do Azure usando o assistente de Backup ou Restauração do SQL Server Management Studio não está habilitado no momento.

• Não há suporte para a criação de um nome de dispositivo lógico. Portanto, não há suporte para a adição de uma URL como dispositivo de backup por meio de sp_dumpdevice ou do SQL Server Management Studio.

• Não há suporte para a anexação de blobs de backup. Os backups em um Blob existente só podem ser substituídos através da opção WITH FORMAT.

• Não há suporte para backup em vários blobs em uma única operação de backup. O exemplo a seguir retornará um erro:

  BACKUP DATABASE AdventureWorks2012
  TO URL = 'https://mystorageaccount.blob.core.windows.net/mycontainer/AdventureWorks2012_1.bak'
     URL = 'https://mystorageaccount.blob.core.windows.net/mycontainer/AdventureWorks2012_2.bak'
        WITH CREDENTIAL = 'mycredential'
       ,STATS = 5;  
  GO
  

• Não há suporte para a especificação de um tamanho de bloco com BACKUP.

• Não há suporte para a especificação de MAXTRANSFERSIZE.

• Não há suporte para a especificação das opções de conjunto de backup - RETAINDAYS e EXPIREDATE.

• SQL Server tem um limite máximo de 259 caracteres em um nome de dispositivo de backup. O BACKUP TO URL consome 36 caracteres para os elementos necessários usados para especificar a URL – 'https://.blob.core.windows.net//.bak ', deixando 223 caracteres para os nomes da conta, do contêiner e do blob juntos.

Suporte a instruções de backup/restauração

Para obter a sintaxe e informações gerais sobre as instruções de backup, confira BACKUP (Transact-SQL).

Para obter a sintaxe e informações gerais sobre as instruções de restauração, confira RESTORE (Transact-SQL).

Suporte para argumentos de backup

Para obter mais informações sobre os argumentos de backup, confira BACKUP (Transact-SQL).

Suporte para argumentos de restauração

Para obter mais informações sobre os argumentos de restauração, confira RESTORE Arguments (Transact-SQL).

Usando a tarefa de backup no SQL Server Management Studio

A tarefa Backup no SQL Server Management Studio foi aprimorada para incluir a URL como uma das opções de destino e outros objetos de suporte necessários para fazer backup no armazenamento do Azure, como a Credencial do SQL.

As etapas a seguir descrevem as alterações feitas na tarefa Backup do Banco de Dados para permitir o backup no armazenamento do Azure.:

1. Inicie o SQL Server Management Studio e conecte-se à instância do SQL Server. Selecione um banco de dados que você deseja fazer backup e clique com o botão direito do mouse em Tarefas e selecione Fazer Backup... Isso abre a caixa de diálogo Fazer Backup do Banco de Dados.

2. Na página geral, a opção URL é usada para criar um backup no armazenamento do Azure. Quando você selecionar essa opção, verá outras opções habilitadas na página:

   1. Nome do arquivo: Nome do arquivo de backup.

   2. Credencial do SQL: Você pode especificar uma credencial SQL Server existente ou pode criar uma nova clicando na caixa Criar ao lado da Credencial do SQL.

      Importante

      A caixa de diálogo que é aberta quando você clica em Criar exige um certificado de gerenciamento ou o perfil da publicação para a assinatura. No momento, o SQL Server oferece suporte à versão do perfil de publicação 2.0. Para baixar a versão com suporte do perfil de publicação, consulte Download do perfil de publicação 2.0.

      Se você não tiver acesso ao certificado de gerenciamento ou perfil de publicação, poderá criar uma credencial de SQL especificando o nome da conta de armazenamento e as informações da chave de acesso usando Transact-SQL ou SQL Server Management Studio. Consulte o código de exemplo na seção Criar uma credencial para criar uma credencial usando Transact-SQL. Como alternativa, usando o SQL Server Management Studio, na instância do mecanismo de banco de dados, clique com o botão direito do mouse em Segurança, selecione Novoe Credencial. Especifique o nome da conta de armazenamento para Identidade e a chave de acesso no campo Senha .

   3. Contêiner de armazenamento do Azure: O nome do contêiner de armazenamento do Azure para armazenar os arquivos de backup.

   4. Prefixo da URL: Isso é criado automaticamente usando as informações especificadas nos campos descritos nas etapas anteriores. Se você editar esse valor manualmente, verifique se ele corresponde às outras informações fornecidas anteriormente. Por exemplo, se você modificar a URL de armazenamento, verifique se a Credencial SQL será definida para ser autenticada na mesma conta de armazenamento.

Quando você selecionar URL como destino, determinadas opções na página Opções de Mídia serão desabilitadas. Os tópicos a seguir têm mais informações na caixa de diálogo Backup de Banco de Dados:

Backup do banco de dados (página Geral)

Backup de Banco de Dados (página Opções de Mídia)

Backup de Banco de Dados (página Opções de Backup)

Criar credencial – autenticar no Armazenamento do Azure

Backup do SQL Server para a URL usando o Assistente de Plano de Manutenção

Semelhante à tarefa de backup descrita anteriormente, o Assistente de Plano de Manutenção no SQL Server Management Studio foi aprimorado para incluir a URL como uma das opções de destino e outros objetos de suporte necessários para fazer backup no armazenamento do Azure, como a Credencial do SQL. Para obter mais informações, consulte a seção Definir Tarefas de Backup no Assistente para Uso do Plano de Manutenção.

Restaurar a partir do armazenamento do Azure por meio do SQL Server Management Studio

Se você estiver restaurando um banco de dados, a URL será incluída como o dispositivo a partir do qual a restauração será realizada. As etapas a seguir descrevem as alterações na tarefa Restaurar para permitir a restauração do armazenamento do Azure:

1. Quando você seleciona Dispositivos na página Geral da tarefa Restaurar no SQL Server Management Studio, a caixa de diálogo Selecione dispositivos de backup , que inclui URL como um tipo de mídia de backup, é exibida.

2. Quando você seleciona URL e clica em Adicionar, a caixa de diálogo Conectar-se ao armazenamento do Windows Azure é aberta. Especifique as informações de Credencial do SQL a serem autenticadas no armazenamento do Azure.

3. SQL Server se conecta ao armazenamento do Azure usando as informações de Credencial do SQL fornecidas e abre a caixa de diálogo Localizar Arquivo de Backup no Azure. Os arquivos de backup que residem no armazenamento são exibidos nessa página. Selecione o arquivo que deseja usar para restaurar e clique em OK. Isso o levará de volta à caixa de diálogo Selecionar Dispositivos de Backup e clicar em OK nessa caixa de diálogo o levará de volta à caixa de diálogo Restaurar main, na qual você poderá concluir a restauração. Para obter mais informações, consulte os seguintes tópicos:

   Restaurar banco de dados (página Geral)

   Restaurar banco de dados (página de arquivos)

   Restaurar o banco de dados (página Opções)

Exemplos de código

Esta seção contém os seguintes exemplos:

• Criar uma credencial

• Fazendo backup de um banco de dados completo

• Fazendo backup do banco de dados e do log

• Criando um backup de arquivo completo do grupo de arquivos primário

• Criando um backup de arquivo diferencial dos grupos de arquivos primários

• Restaurando um banco de dados e movendo arquivos

• Restauração pontual usando STOPAT

Create a Credential

O exemplo a seguir cria uma credencial que armazena as informações de autenticação do Armazenamento do Azure.

IF NOT EXISTS  
(SELECT * FROM sys.credentials   
WHERE credential_identity = 'mycredential')  
CREATE CREDENTIAL mycredential WITH IDENTITY = 'mystorageaccount'  
,SECRET = '<storage access key>' ;  

// Connect to default sql server instance on local machine  
Server server = new Server(".");  
string identity = "mystorageaccount";  
string secret = "<storage access key>";  

// Create a Credential  
string credentialName = "mycredential";  
Credential credential = new Credential(server, credentialName);  
credential.Create(identity, secret);  

# create variables  
$storageAccount = "mystorageaccount"  
$storageKey = "<storage access key>"  
$secureString = ConvertTo-SecureString $storageKey  -asplaintext -force  
$credentialName = "mycredential"  

$srvPath = "SQLSERVER:\SQL\COMPUTERNAME\INSTANCENAME"  
# for default instance, the $srvpath variable would be "SQLSERVER:\SQL\COMPUTERNAME\DEFAULT"  

# Create a credential  
New-SqlCredential -Name $credentialName -Path $srvpath -Identity $storageAccount -Secret $secureString

Fazendo backup de um banco de dados completo

O exemplo a seguir faz backup do banco de dados AdventureWorks2012 para o serviço de Armazenamento de Blobs do Azure.

BACKUP DATABASE AdventureWorks2012   
TO URL = 'https://mystorageaccount.blob.core.windows.net/mycontainer/AdventureWorks2012.bak'   
      WITH CREDENTIAL = 'mycredential'   
      ,COMPRESSION  
      ,STATS = 5;  
GO

// Connect to default sql server instance on local machine  
Server server = new Server(".");  
string identity = "mystorageaccount";  

string credentialName = "mycredential";  
string dbName = "AdventureWorks2012";  
string blobContainerName = "mycontainer";  

// Generate Unique Url  
string url = String.Format(@"https://{0}.blob.core.windows.net/{1}/{2}-{3}.bak",  
         identity,  
         blobContainerName,  
         dbName,  
         DateTime.Now.ToString("s").Replace(":", "-"));  

// Backup to Url  
Backup backup = new Backup();  
backup.CredentialName = credentialName;  
backup.Database = dbName;  
backup.CompressionOption = BackupCompressionOptions.On;  
backup.Devices.AddDevice(url, DeviceType.Url);  
backup.SqlBackup(server);  

# create variables  
$backupUrlContainer = "https://mystorageaccount.blob.core.windows.net/mycontainer/"  
$credentialName = "mycredential"  
$srvPath = "SQLSERVER:\SQL\COMPUTERNAME\INSTANCENAME"   
# for default instance, the $srvpath varilable would be "SQLSERVER:\SQL\COMPUTERNAME\DEFAULT"  

# navigate to SQL Server Instance  
CD $srvPath   
$backupFile = $backupUrlContainer + "AdventureWorks2012" +  ".bak"  
Backup-SqlDatabase -Database AdventureWorks2012 -backupFile $backupFile  -SqlCredential $credentialName -CompressionOption On

Fazendo backup do banco de dados e do log

O exemplo a seguir faz backup do banco de dados de exemplo AdventureWorks2012, que, por padrão, usa o modelo de recuperação simples. Para oferecer suporte a backups de log, o banco de dados AdventureWorks2012 é modificado para usar o modelo de recuperação completa. Em seguida, o exemplo cria um backup completo do banco de dados para o Blob do Azure e, após um período de atividade de atualização, faz backup do log. Esse exemplo cria um nome de arquivo de backup com um carimbo de data/hora.

-- To permit log backups, before the full database backup, modify the database   
-- to use the full recovery model.  
USE master;  
GO  
ALTER DATABASE AdventureWorks2012  
   SET RECOVERY FULL;  
GO  

-- Back up the full AdventureWorks2012 database.  
       -- First create a file name for the backup file with DateTime stamp  

DECLARE @Full_Filename AS VARCHAR (300);  
SET @Full_Filename = 'https://mystorageaccount.blob.core.windows.net/mycontainer/AdventureWorks2012_Full_'+   
REPLACE (REPLACE (REPLACE (CONVERT (VARCHAR (40), GETDATE (), 120), '-','_'),':', '_'),' ', '_') + '.bak';   
--Back up Adventureworks2012 database  

BACKUP DATABASE AdventureWorks2012  
TO URL =  @Full_Filename  
WITH CREDENTIAL = 'mycredential';  
,COMPRESSION  
GO  
-- Back up the AdventureWorks2012 log.  
DECLARE @Log_Filename AS VARCHAR (300);  
SET @Log_Filename = 'https://mystorageaccount.blob.core.windows.net/mycontainer/AdventureWorks2012_Log_'+   
REPLACE (REPLACE (REPLACE (CONVERT (VARCHAR (40), GETDATE (), 120), '-','_'),':', '_'),' ', '_') + '.trn';  
BACKUP LOG AdventureWorks2012  
 TO URL = @Log_Filename  
 WITH CREDENTIAL = 'mycredential'  
 ,COMPRESSION;  
GO  

// Connect to default sql server instance on local machine  
Server server = new Server(".");  
string identity = "mystorageaccount";  

string credentialName = "mycredential";  
string dbName = "AdventureWorks2012";  
string blobContainerName = "mycontainer";  

// Generate Unique Url for data backup  
string urlDataBackup = String.Format(@"https://{0}.blob.core.windows.net/{1}/{2}_Data-{3}.bak",  
         identity,  
         blobContainerName,  
         dbName,  
         DateTime.Now.ToString("s").Replace(":", "-"));  

// Backup Database to Url  
Backup backupData = new Backup();  
backupData.CredentialName = credentialName;  
backupData.Database = dbName;  
backup.CompressionOption = BackupCompressionOptions.On;  
backupData.Devices.AddDevice(urlDataBackup, DeviceType.Url);  
backupData.SqlBackup(server);  

// Generate Unique Url for data backup  
string urlLogBackup = String.Format(@"https://{0}.blob.core.windows.net/{1}/{2}_Log-{3}.bak",  
         identity,  
         blobContainerName,  
         dbName,  
         DateTime.Now.ToString("s").Replace(":", "-"));  

// Backup Database Log to Url  
Backup backupLog = new Backup();  
backupLog.CredentialName = credentialName;  
backupLog.Database = dbName;  
backup.CompressionOption = BackupCompressionOptions.On;  
backupLog.Devices.AddDevice(urlLogBackup, DeviceType.Url);  
backupLog.Action = BackupActionType.Log;  
backupLog.SqlBackup(server);  

#create variables  
$backupUrlContainer = "https://mystorageaccount.blob.core.windows.net/mycontainer/"  
$credentialName = "mycredential"  
$srvPath = "SQLSERVER:\SQL\COMPUTERNAME\INSTANCENAME"  
# for default instance, the $srvpath variable would be "SQLSERVER:\SQL\COMPUTERNAME\DEFAULT"  

# navigate to theSQL Server Instance
CD $srvPath   
#Create a unique file name for the full database backup  
$backupFile = $backupUrlContainer + "AdventureWorks2012_" + (Get-Date).ToString("s").Replace("-","_").Replace(":", "_").Replace(" ","_").Replace("/", "_") +  ".bak"  

#Backup Database to URL
Backup-SqlDatabase -Database AdventureWorks2012 -backupFile $backupFile  -SqlCredential $credentialName -CompressionOption On -BackupAction Database    

#Create a unique file name for log backup  

$backupFile = $backupUrlContainer + "AdventureWorks2012_" + (Get-Date).ToString("s").Replace("-","_").Replace(":", "_").Replace(" ","_").Replace("/", "_") +  ".trn"  

#Backup Log to URL
Backup-SqlDatabase -Database AdventureWorks2012 -backupFile $backupFile  -SqlCredential $credentialName -CompressionOption On -BackupAction Log

Criando um backup de arquivo completo do grupo de arquivos primário

O exemplo a seguir cria um backup de arquivo completo do grupo de arquivos primário.

--Back up the files in Primary:  
BACKUP DATABASE AdventureWorks2012  
    FILEGROUP = 'Primary'  
    TO URL = 'https://mystorageaccount.blob.core.windows.net/mycontainer/AdventureWorks2012files.bck'  
    WITH CREDENTIAL = 'mycredential'  
    ,COMPRESSION;  
GO  

// Connect to default sql server instance on local machine  
Server server = new Server(".");  
string identity = "mystorageaccount";  

string credentialName = "mycredential";  
string dbName = "AdventureWorks2012";  
string blobContainerName = "mycontainer";  

// Generate Unique Url  
string url = String.Format(@"https://{0}.blob.core.windows.net/{1}/{2}-{3}.bck",  
         identity,  
         blobContainerName,  
         dbName,  
         DateTime.Now.ToString("s").Replace(":", "-"));  

// Backup to Url  
Backup backup = new Backup();  
backup.CredentialName = credentialName;  
backup.Database = dbName;  
backup.Action = BackupActionType.Files;  
backup.DatabaseFileGroups.Add("PRIMARY");  
backup.CompressionOption = BackupCompressionOptions.On;  
backup.Devices.AddDevice(url, DeviceType.Url);  
backup.SqlBackup(server);

#create variables  
$backupUrlContainer = "https://mystorageaccount.blob.core.windows.net/mycontainer/"  
$credentialName = "mycredential"  
$srvPath = "SQLSERVER:\SQL\COMPUTERNAME\INSTANCENAME"  
# for default instance, the $srvpath variable would be "SQLSERVER:\SQL\COMPUTERNAME\DEFAULT"  

# navigate to the SQL Server Instance  

CD $srvPath   
#Create a unique file name for the file backup  
$backupFile = $backupUrlContainer + "AdventureWorks2012_" + (Get-Date).ToString("s").Replace("-","_").Replace(":", "_").Replace(" ","_").Replace("/", "_") +  ".bck"  

#Backup Primary File Group to URL  

Backup-SqlDatabase -Database AdventureWorks2012 -backupFile $backupFile  -SqlCredential $credentialName -CompressionOption On -BackupAction Files -DatabaseFileGroup Primary

Criando um backup de arquivo diferencial dos grupo de arquivos primário

O exemplo a seguir cria um backup de arquivo diferencial do grupo de arquivos primário.

--Back up the files in Primary:  
BACKUP DATABASE AdventureWorks2012  
    FILEGROUP = 'Primary'  
    TO URL = 'https://mystorageaccount.blob.core.windows.net/mycontainer/AdventureWorks2012filesdiff.bck'  
    WITH   
       CREDENTIAL = 'mycredential'  
       ,COMPRESSION  
   ,DIFFERENTIAL;  
GO

// Connect to default sql server instance on local machine  
Server server = new Server(".");  
string identity = "mystorageaccount";  

string credentialName = "mycredential";  
string dbName = "AdventureWorks2012";  
string blobContainerName = "mycontainer";  

// Generate Unique Url  
string url = String.Format(@"https://{0}.blob.core.windows.net/{1}/{2}-{3}.bak",  
         identity,  
         blobContainerName,  
         dbName,  
         DateTime.Now.ToString("s").Replace(":", "-"));  

// Backup to Url  
Backup backup = new Backup();  
backup.CredentialName = credentialName;  
backup.Database = dbName;  
backup.Action = BackupActionType.Files;  
backup.DatabaseFileGroups.Add("PRIMARY");  
backup.Incremental = true;  
backup.CompressionOption = BackupCompressionOptions.On;  
backup.Devices.AddDevice(url, DeviceType.Url);  
backup.SqlBackup(server); 

#create variables  
$backupUrlContainer = "https://mystorageaccount.blob.core.windows.net/mycontainer/"  
$credentialName = "mycredential"  
$srvPath = "SQLSERVER:\SQL\COMUTERNAME\INSTANCENAME"  
# for default instance, the $srvpath variable would be "SQLSERVER:\SQL\COMPUTERNAME\DEFAULT"  

# navigate to SQL Server Instance
CD $srvPath   

#create a unique file name for the full backup  
$backupdbFile = $backupUrlContainer + "AdventureWorks2012_" + (Get-Date).ToString("s").Replace("-","_").Replace(":", "_").Replace(" ","_").Replace("/", "_") +  ".bak"  

#Create a differential backup of the primary filegroup
Backup-SqlDatabase -Database AdventureWorks2012 -backupFile $backupFile  -SqlCredential $credentialName -CompressionOption On -BackupAction Files -DatabaseFileGroup Primary -Incremental

Restaurar um banco de dados e mover arquivos

Para restaurar um backup de banco de dados completo e mover o banco de dados restaurado para o diretório C:\Arquivos de Programas\Microsoft SQL Server\MSSQL12.MSSQLSERVER\MSSQL\Data, execute as etapas a seguir.

-- Backup the tail of the log first
DECLARE @Log_Filename AS VARCHAR (300);  
SET @Log_Filename = 'https://mystorageaccount.blob.core.windows.net/mycontainer/AdventureWorks2012_Log_'+   
REPLACE (REPLACE (REPLACE (CONVERT (VARCHAR (40), GETDATE (), 120), '-','_'),':', '_'),' ', '_') + '.trn';  
BACKUP LOG AdventureWorks2012  
 TO URL = @Log_Filename  
 WITH CREDENTIAL = 'mycredential'  
 ,NORECOVERY;  
GO  

RESTORE DATABASE AdventureWorks2012 FROM URL = 'https://mystorageaccount.blob.core.windows.net/mycontainer/AdventureWorks2012.bak'  
WITH CREDENTIAL = 'mycredential'  
 ,MOVE 'AdventureWorks2012_data' to 'C:\Program Files\Microsoft SQL Server\myinstance\MSSQL\DATA\AdventureWorks2012.mdf'  
 ,MOVE 'AdventureWorks2012_log' to 'C:\Program Files\Microsoft SQL Server\myinstance\MSSQL\DATA\AdventureWorks2012.ldf'  
 ,STATS = 5

// Connect to default sql server instance on local machine  
Server server = new Server(".");  
string identity = "mystorageaccount";  

string credentialName = "mycredential";  
string dbName = "AdventureWorks2012";  
string blobContainerName = "mycontainer";  

// Generate Unique Url  
string urlBackupData = String.Format(@"https://{0}.blob.core.windows.net/{1}/{2}-Data{3}.bak",  
         identity,  
         blobContainerName,  
         dbName,  
         DateTime.Now.ToString("s").Replace(":", "-"));  

// Backup to Url  
Backup backup = new Backup();  
backup.CredentialName = credentialName;  
backup.Database = dbName;  
backup.Devices.AddDevice(urlBackupData, DeviceType.Url);  
backup.SqlBackup(server);  

// Generate Unique Url for tail log backup  
string urlTailLogBackup = String.Format(@"https://{0}.blob.core.windows.net/{1}/{2}-TailLog{3}.bak",  
         identity,  
         blobContainerName,  
         dbName,  
         DateTime.Now.ToString("s").Replace(":", "-"));  

// Backup Tail Log to Url  
Backup backupTailLog = new Backup();  
backupTailLog.CredentialName = credentialName;  
backupTailLog.Database = dbName;  
backupTailLog.Action = BackupActionType.Log;  
backupTailLog.NoRecovery = true;  
backupTailLog.Devices.AddDevice(urlTailLogBackup, DeviceType.Url);  
backupTailLog.SqlBackup(server);  

// Restore a database and move files  
string newDataFilePath = server.MasterDBLogPath  + @"\" + dbName + DateTime.Now.ToString("s").Replace(":", "-") + ".mdf";  
string newLogFilePath = server.MasterDBLogPath  + @"\" + dbName + DateTime.Now.ToString("s").Replace(":", "-") + ".ldf";  

Restore restore = new Restore();  
restore.CredentialName = credentialName;  
restore.Database = dbName;  
restore.ReplaceDatabase = true;  
restore.Devices.AddDevice(urlBackupData, DeviceType.Url);  
restore.RelocateFiles.Add(new RelocateFile(dbName, newDataFilePath));  
restore.RelocateFiles.Add(new RelocateFile(dbName+ "_Log", newLogFilePath));  
restore.SqlRestore(server);

#create variables  
$backupUrlContainer = "https://mystorageaccount.blob.core.windows.net/mycontainer/"  
$credentialName = "mycredential"  
$srvPath = "SQLSERVER:\SQL\COMPUTERNAME\INSTNACENAME"  
# for default instance, the $srvpath variable would be "SQLSERVER:\SQL\COMPUTERNAME\DEFAULT"  

# navigate to SQL Server Instance
CD $srvPath   

#create a unique file name for the full backup  
$backupdbFile = $backupUrlContainer + "AdventureWorks2012_" + (Get-Date).ToString("s").Replace("-","_").Replace(":", "_").Replace(" ","_").Replace("/", "_") +  ".bak"  

# Full database backup to URL  
Backup-SqlDatabase -Database AdventureWorks2012 -backupFile $backupdbFile  -SqlCredential $credentialName -CompressionOption On      

#Create a unique file name for the tail log backup  
$backuplogFile = $backupUrlContainer + "AdventureWorks2012_" + (Get-Date).ToString("s").Replace("-","_").Replace(":", "_").Replace(" ","_").Replace("/", "_") +  ".trn"  

#Backup tail log to URL
Backup-SqlDatabase -Database AdventureWorks2012 -backupFile $backupFile  -SqlCredential $credentialName  -BackupAction Log -NoRecovery    

# Restore Database and move files
$newDataFilePath = New-Object Microsoft.SqlServer.Management.Smo.RelocateFile ("AdventureWorks_Data","C:\Program Files\Microsoft SQL Server\myinstance\MSSQL\DATA\AdventureWorks2012.mdf")  
$newLogFilePath = New-Object Microsoft.SqlServer.Management.Smo.RelocateFile("AdventureWorks_Log","C:\Program Files\Microsoft SQL Server\myinstance\MSSQL\DATA\AdventureWorks2012.ldf")  

Restore-SqlDatabase -Database AdventureWorks2012 -SqlCredential $credentialName -BackupFile $backupdbFile -RelocateFile @($newDataFilePath,$newLogFilePath)

Restauração pontual usando STOPAT

O exemplo a seguir restaura um banco de dados para seu estado em um determinado ponto e mostra uma operação de restauração.

RESTORE DATABASE AdventureWorks FROM URL = 'https://mystorageaccount.blob.core.windows.net/mycontainer/AdventureWorks2012.bak'   
WITH   
  CREDENTIAL = 'mycredential'  
 ,MOVE 'AdventureWorks2012_data' to 'C:\Program Files\Microsoft SQL Server\myinstance\MSSQL\DATA\AdventureWorks2012.mdf'  
 ,Move 'AdventureWorks2012_log' to 'C:\Program Files\Microsoft SQL Server\myinstance\MSSQL\DATA\AdventureWorks2012.ldf'  
 ,NORECOVERY  
 --,REPLACE  
 ,STATS = 5;  
GO   

RESTORE LOG AdventureWorks FROM URL = 'https://mystorageaccount.blob.core.windows.net/mycontainer/AdventureWorks2012.trn'   
WITH CREDENTIAL = 'mycredential'  
 ,RECOVERY   
 ,STOPAT = 'Oct 23, 2012 5:00 PM'   
GO  

// Connect to default sql server instance on local machine  
Server server = new Server(".");  
string identity = "mystorageaccount";  

string credentialName = "mycredential";  
string dbName = "AdventureWorks2012";  
string blobContainerName = "mycontainer";  

// Generate Unique Url  
string urlBackupData = String.Format(@"https://{0}.blob.core.windows.net/{1}/{2}-Data{3}.bak",  
         identity,  
         blobContainerName,  
         dbName,  
         DateTime.Now.ToString("s").Replace(":", "-"));  

// Backup to Url  
Backup backup = new Backup();  
backup.CredentialName = credentialName;  
backup.Database = dbName;  
backup.Devices.AddDevice(urlBackupData, DeviceType.Url);  
backup.SqlBackup(server);  

// Generate Unique Url for Tail Log backup  
string urlTailLogBackup = String.Format(@"https://{0}.blob.core.windows.net/{1}/{2}-TailLog{3}.bak",  
         identity,  
         blobContainerName,  
         dbName,  
         DateTime.Now.ToString("s").Replace(":", "-"));  

// Backup Tail Log to Url  
Backup backupTailLog = new Backup();  
backupTailLog.CredentialName = credentialName;  
backupTailLog.Database = dbName;  
backupTailLog.Action = BackupActionType.Log;  
backupTailLog.NoRecovery = true;  
backupTailLog.Devices.AddDevice(urlTailLogBackup, DeviceType.Url);  
backupTailLog.SqlBackup(server);  

// Restore a database and move files  
string newDataFilePath = server.MasterDBLogPath + @"\" + dbName + DateTime.Now.ToString("s").Replace(":", "-") + ".mdf";  
string newLogFilePath = server.MasterDBLogPath + @"\" + dbName + DateTime.Now.ToString("s").Replace(":", "-") + ".ldf";  

Restore restore = new Restore();  
restore.CredentialName = credentialName;  
restore.Database = dbName;  
restore.ReplaceDatabase = true;  
restore.NoRecovery = true;  
restore.Devices.AddDevice(urlBackupData, DeviceType.Url);  
restore.RelocateFiles.Add(new RelocateFile(dbName, newDataFilePath));  
restore.RelocateFiles.Add(new RelocateFile(dbName + "_Log", newLogFilePath));  
restore.SqlRestore(server);  
   
// Restore transaction Log with stop at   
Restore restoreLog = new Restore();  
restoreLog.CredentialName = credentialName;  
restoreLog.Database = dbName;  
restoreLog.Action = RestoreActionType.Log;  
restoreLog.Devices.AddDevice(urlBackupData, DeviceType.Url);  
restoreLog.ToPointInTime = DateTime.Now.ToString();   
restoreLog.SqlRestore(server);

#create variables  
$backupUrlContainer = "https://mystorageaccount.blob.core.windows.net/mycontainer/"  
$credentialName = "mycredential"  
$srvPath = "SQLSERVER:\SQL\COMPUTERNAME\INSTANCENAME"  
# for default instance, the $srvpath variable would be "SQLSERVER:\SQL\COMPUTERNAME\DEFAULT"  

# Navigate to SQL Server Instance Directory
CD $srvPath   

#create a unique file name for the full backup  
$backupdbFile = $backupUrlContainer + "AdventureWorks2012_" + (Get-Date).ToString("s").Replace("-","_").Replace(":", "_").Replace(" ","_").Replace("/", "_") +  ".bak"  

# Full database backup to URL  
Backup-SqlDatabase -Database AdventureWorks2012 -backupFile $backupdbFile  -SqlCredential $credentialName -CompressionOption On     

#Create a unique file name for the tail log backup  
$backuplogFile = $backupUrlContainer + "AdventureWorks2012_" + (Get-Date).ToString("s").Replace("-","_").Replace(":", "_").Replace(" ","_").Replace("/", "_") +  ".trn"  

#Backup tail log to URL
Backup-SqlDatabase -Database AdventureWorks2012 -backupFile $backupFile  -SqlCredential $credentialName  -BackupAction Log -NoRecovery     

# Restore Database and move files
$newDataFilePath = New-Object Microsoft.SqlServer.Management.Smo.RelocateFile ("AdventureWorks_Data","C:\Program Files\Microsoft SQL Server\myinstance\MSSQL\DATA\AdventureWorks2012.mdf")  
$newLogFilePath = New-Object Microsoft.SqlServer.Management.Smo.RelocateFile("AdventureWorks_Log","C:\Program Files\Microsoft SQL Server\myinstance\MSSQL\DATA\AdventureWorks2012.ldf")  

Restore-SqlDatabase -Database AdventureWorks2012 -SqlCredential $credentialName -BackupFile $backupdbFile -RelocateFile @($newDataFilePath,$newLogFilePath) -NoRecovery    

# Restore Transaction log with Stop At:  
Restore-SqlDatabase -Database AdventureWorks2012 -SqlCredential $credentialName -BackupFile $backuplogFile  -ToPointInTime (Get-Date).ToString()

Consulte Também

Solução de problemas e melhores práticas de backup do SQL Server para URL
Fazer backup e restaurar bancos de dados do sistema (SQL Server)