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 um destino de backup. A funcionalidade de backup e restauração é igual ou semelhante a quando se utiliza DISCO ou FITA, com algumas diferenças. As diferenças, juntamente com quaisquer exceções notáveis, e alguns exemplos de código estão incluídos neste tópico.

Requisitos, componentes e conceitos

Nesta seção:

Segurança

Veja a seguir considerações de segurança e requisitos 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. Definir o acesso a privado restringe o acesso a usuários ou contas capazes de fornecer as informações necessárias para autenticar na conta do Azure.

Importante

O SQL Server requer que o nome da conta do Azure e a autenticação de chave de acesso sejam armazenados em uma Credencial do 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 comandos BACKUP ou RESTORE deve ter permissões de Alterar qualquer credencial e estar na função de banco de dados do operador db_backup.

Introdução aos principais componentes e conceitos

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

Criar uma conta do Azure é a primeira etapa para esse processo. O 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 da criação de uma conta de armazenamento e a execução de uma restauração simples, consulte Tutorial Usando o Serviço de Armazenamento do Azure para Backup e Restauração do SQL Server.

mapeando a conta de armazenamento para credenciais sql

Serviço de Armazenamento de Blobs do Azure

Conta de armazenamento: A conta de armazenamento é o ponto de partida para todos os serviços de armazenamento. Para acessar o serviço de 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 se autenticar no serviço de 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 do 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. O backup do SQL Server usa Page Blobs 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>

Armazenamento de Blobs do Azure

Para obter mais informações sobre o serviço de Armazenamento de Blobs do Azure, consulte Como usar o Serviço de 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ágina em uma conta de armazenamento do Azure. A URL deve apontar para um Blob real, não apenas um contêiner. Se o Blob não existir, ele será criado. Se um Blob existente for especificado, o BACKUP falhará, a menos que a opção "WITH FORMAT" seja especificada.

Aviso

Se você escolher copiar e enviar um arquivo de backup para o serviço de Armazenamento de Blobs do Azure, use o 'page blob' como sua opção de armazenamento. Não há suporte para restaurações de Blobs de bloco. A RESTAURAÇÃO de um blob de bloco falhará.

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

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

Para obter instruções passo a passo sobre como criar uma Credencial do 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 do SQL Server Agent.

Limitações

Não há suporte para o backup no armazenamento premium.
O tamanho máximo de backup com suporte é de 1 TB.
Você pode emitir instruções de backup ou restauração usando cmdlets TSQL, SMO ou PowerShell. No momento, não está habilitado fazer backup para ou restaurar do serviço de Armazenamento de Blobs do Azure usando o assistente de Backup ou Restauração do SQL Server Management Studio.
Não há suporte para a criação de um nome de dispositivo lógico. Portanto, não há suporte para adicionar URL como um dispositivo de backup usando sp_dumpdevice ou por meio do SQL Server Management Studio.
Não há suporte para acrescentar a blobs de backup existentes. Os backups em um Blob existente só podem ser substituídos usando a opção WITH FORMAT.

Não há suporte para backup em vários blobs em uma única operação de backup. Por exemplo, o seguinte retorna 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 especificar um tamanho de bloco com BACKUP .
Não há suporte para especificação MAXTRANSFERSIZE .
Especificando opções de conjunto de backup – RETAINDAYS e EXPIREDATE não são suportados.
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 para instruções de backup/restauração


Instrução de Backup/Restauração	Suportado	Exceções	Comentários
Cópia de segurança	✓	NÃO há suporte para BLOCKSIZE e MAXTRANSFERSIZE.	Requer COM CREDENCIAL especificada
RESTAURAR	✓		Requer que WITH CREDENTIAL seja especificado
RESTORE FILELISTONLY (Comando SQL para restaurar apenas a lista de arquivos)	✓		Requer COM CREDENCIAL especificada
RESTAURAR HEADERONLY	✓		Requer COM CREDENCIAL especificada
RESTAURAR LABELONLY	✓		Requer COM CREDENCIAL especificado
RESTORE VERIFYONLY	✓		Requer COM CREDENCIAL especificada
RESTAURAR REWINDONLY	✓

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

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

Suporte para argumentos de backup


Argumento	Suportado	Exceção	Comentários
BASE DE DADOS	✓
Registro	✓

TO (URL)	✓	Ao contrário do DISCO e da FITA, a URL não dá suporte à especificação ou à criação de um nome lógico.	Esse argumento é usado para especificar o caminho da URL para o arquivo de backup.
REFLETIR PARA	✓
COM OPÇÕES:
CREDENCIAL	✓		O WITH CREDENTIAL só tem suporte ao usar a opção BACKUP TO URL para fazer backup no serviço de Armazenamento de Blobs do Azure.
DIFERENCIAL	✓
COPY_ONLY	✓
COMPRESSION\|NO_COMPRESSION	✓
DESCRIÇÃO	✓
NOME	✓
DATA DE EXPIRAÇÃO \| DIAS DE RETENÇÃO	✓
NOINIT \| INIT	✓		Essa opção será ignorada se usada. Não é possível acrescentar a blobs. Para substituir um backup, use o argumento FORMAT.
NOSKIP \| SALTITAR	✓
NOFORMAT \| FORMATO	✓		Essa opção será ignorada se usada. Um backup feito em um blob existente falha, a menos que WITH FORMAT seja especificado. O blob existente é substituído quando WITH FORMAT é especificado.
DESCRIÇÃO DA MÍDIA	✓
MEDIANAME	✓
BLOCKSIZE	✓
BUFFERCOUNT	✓
MAXTRANSFERSIZE	✓
NO_CHECKSUM \| CHECKSUM	✓
STOP_ON_ERROR \| CONTINUE_AFTER_ERROR	✓
ESTATÍSTICAS	✓
REWIND \| NOREWIND	✓
DESCARREGAR \| NÃO DESCARREGAR	✓
NORECOVERY \| STANDBY	✓
SEM_TRUNCAR	✓

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

Suporte para argumentos de restauração


Argumento	Suportado	Exceções	Comentários
BASE DE DADOS	✓
REGISTRO	✓
DE (URL)	✓		O argumento DA URL é usado para especificar o caminho da URL para o arquivo de backup.
Com Opções:
CREDENCIAL	✓		O recurso WITH CREDENTIAL é suportado apenas quando se utiliza a opção RESTORE FROM URL para restaurar do serviço de Armazenamento de Blobs do Azure.
PARCIAL	✓
RECUPERAÇÃO \| SEM RECUPERAÇÃO \| ESPERA	✓
LOADHISTORY	✓
MOVER	✓
SUBSTITUIR	✓
REINICIAR	✓
RESTRICTED_USER	✓
ARQUIVO	✓
SENHA	✓
MEDIANAME	✓
MEDIAPASSWORD	✓
BLOCKSIZE	✓
BUFFERCOUNT	✓
MAXTRANSFERSIZE	✓
CHECKSUM \| NO_CHECKSUM	✓
PARAR_EM_ERRO \| CONTINUAR_APÓS_ERRO	✓
FILESTREAM	✓
ESTATÍSTICAS	✓
REWIND \| NOREWIND	✓
UNLOAD \| NOUNLOAD	✓
MANTER_REPLICAÇÃO	✓
KEEP_CDC	✓
ENABLE_BROKER \| ERROR_BROKER_CONVERSATIONS \| NEW_BROKER	✓
STOPAT \| STOPATMARK \| STOPBEFOREMARK	✓

Para obter mais informações sobre argumentos restore, consulte 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.:

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.
Na página geral, a opção URL é usada para criar um backup no armazenamento do Azure. Ao selecionar essa opção, você verá outras opções habilitadas nesta página:
1. Nome do arquivo: Nome do arquivo de backup.
2. Credencial do SQL: Você pode especificar uma credencial existente do SQL Server ou 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 requer um certificado de gerenciamento ou o perfil de publicação da assinatura. Atualmente, o SQL Server dá suporte ao perfil de publicação versão 2.0. Para baixar a versão com suporte do perfil de publicação, consulte Baixar o Perfil de Publicação 2.0.
  
  Se você não tiver acesso ao certificado de gerenciamento ou ao perfil de publicação, poderá criar uma Credencial de SQL especificando o nome da conta de armazenamento e acessar informações de chave 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 o 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 Novo e selecione 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 de 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 do SQL está definida para autenticar na mesma conta de armazenamento.

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

Fazer backup do banco de dados (página geral)

Fazer backup do banco de dados (página Opções de Mídia)

Fazer backup do banco de dados (página Opções de Backup)

Criar Credencial – Autenticar no Armazenamento do Azure

Backup do SQL Server para 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 Usar Plano de Manutenção.

Restauração do armazenamento do Azure usando o SQL Server Management Studio

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

Quando você seleciona Dispositivos na página Geral da tarefa Restaurar no SQL Server Management Studio, isso leva você para a caixa de diálogo Selecionar dispositivos de backup , que inclui URL como um tipo de mídia de backup.
Quando você seleciona a URL e clica em Adicionar, isso abre a caixa de diálogo Conectar ao Armazenamento do Azure . Especifique as informações de credencial do SQL a serem autenticadas no armazenamento do Azure.
Em seguida, o 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 nesta página. Selecione o arquivo que você 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 nesta caixa de diálogo o levará de volta à caixa de diálogo Restauração principal, na qual você poderá concluir a restauração. Para obter mais informações, confira 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 exemplos a seguir.

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 para um ponto específico no tempo usando STOPAT

Criar uma credencial

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 usa o modelo de recuperação simples por padrão. Para dar 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. Este 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 diferencial do 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 C:\Arquivos de Programas\Microsoft SQL Server\MSSQL12. MSSQLSERVER\MSSQL\Diretório de dados, use 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)

Restaurando a um ponto no tempo usando STOPAT

O exemplo a seguir restaura um banco de dados em seu estado para um ponto no tempo 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

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

Last updated on 2019-10-18

Partilhar via